sig   module Std :     sig       module type Node =         sig           type t           type graph           type label           type edge           val create : Graphlib.Std.Node.label -> Graphlib.Std.Node.t           val label : Graphlib.Std.Node.t -> Graphlib.Std.Node.label           val mem : Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> bool           val succs :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.t Regular.Std.seq           val preds :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.t Regular.Std.seq           val inputs :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge Regular.Std.seq           val outputs :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge Regular.Std.seq           val degree :             ?dir:[ `In | `Out ] ->             Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> int           val insert :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph           val update :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.label ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph           val remove :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph           val has_edge :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> bool           val edge :             Graphlib.Std.Node.t ->             Graphlib.Std.Node.t ->             Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge option           val ( >= ) : t -> t -> bool           val ( <= ) : t -> t -> bool           val ( = ) : t -> t -> bool           val ( > ) : t -> t -> bool           val ( < ) : t -> t -> bool           val ( <> ) : t -> t -> bool           val equal : t -> t -> bool           val min : t -> t -> t           val max : t -> t -> t           val ascending : t -> t -> int           val descending : t -> t -> int           val between : t -> low:t -> high:t -> bool           val clamp_exn : t -> min:t -> max:t -> t           val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t           module Replace_polymorphic_compare :             sig               val ( >= ) : t -> t -> bool               val ( <= ) : t -> t -> bool               val ( = ) : t -> t -> bool               val ( > ) : t -> t -> bool               val ( < ) : t -> t -> bool               val ( <> ) : t -> t -> bool               val equal : t -> t -> bool               val compare : t -> t -> int               val min : t -> t -> t               val max : t -> t -> t             end           type comparator_witness           val comparator :             (t, comparator_witness) Core_kernel.Comparator.comparator           val validate_lbound :             min:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_ubound :             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_bound :             min:t Core_kernel.Maybe_bound.t ->             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           module Map :             sig               module Key :                 sig                   type t = t                   type comparator_witness = comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type 'a t =                       (Key.t, 'a, comparator_witness)                       Core_kernel.Core_map.Tree.t                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val empty : 'a t                   val singleton : Key.t -> '-> 'a t                   val of_alist :                     (Key.t * 'a) list ->                     [ `Duplicate_key of Key.t | `Ok of 'a t ]                   val of_alist_or_error :                     (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                   val of_alist_exn : (Key.t * 'a) list -> 'a t                   val of_alist_multi : (Key.t * 'a) list -> 'a list t                   val of_alist_fold :                     (Key.t * 'a) list ->                     init:'-> f:('-> '-> 'b) -> 'b t                   val of_alist_reduce :                     (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                   val of_sorted_array :                     (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t                   val of_tree : 'a t -> 'a t                   val gen :                     Key.t Core_kernel.Quickcheck.Generator.t ->                     'Core_kernel.Quickcheck.Generator.t ->                     'a t Core_kernel.Quickcheck.Generator.t                   val invariants : 'a t -> bool                   val is_empty : 'a t -> bool                   val length : 'a t -> int                   val add : 'a t -> key:Key.t -> data:'-> 'a t                   val add_multi :                     'a list t -> key:Key.t -> data:'-> 'a list t                   val remove_multi : 'a list t -> Key.t -> 'a list t                   val change :                     'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                   val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                   val find : 'a t -> Key.t -> 'a option                   val find_exn : 'a t -> Key.t -> 'a                   val remove : 'a t -> Key.t -> 'a t                   val mem : 'a t -> Key.t -> bool                   val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iteri :                     'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                   val iter2 :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        unit) ->                     unit                   val map : 'a t -> f:('-> 'b) -> 'b t                   val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                   val fold :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold_right :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold2 :                     'a t ->                     'b t ->                     init:'->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        '-> 'c) ->                     'c                   val filter :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filteri :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                   val filter_map : 'a t -> f:('-> 'b option) -> 'b t                   val filter_mapi :                     'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                   val partition_mapi :                     'a t ->                     f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                     'b t * 'c t                   val partition_map :                     'a t ->                     f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                   val partitioni_tf :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                   val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                   val compare_direct :                     ('-> '-> int) -> 'a t -> 'a t -> int                   val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                   val keys : 'a t -> Key.t list                   val data : 'a t -> 'a list                   val to_alist :                     ?key_order:[ `Decreasing | `Increasing ] ->                     'a t -> (Key.t * 'a) list                   val validate :                     name:(Key.t -> string) ->                     'Core_kernel.Validate.check ->                     'a t Core_kernel.Validate.check                   val merge :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        'c option) ->                     'c t                   val symmetric_diff :                     'a t ->                     'a t ->                     data_equal:('-> '-> bool) ->                     (Key.t, 'a)                     Core_kernel.Core_map_intf.Symmetric_diff_element.t                     Core_kernel.Sequence.t                   val min_elt : 'a t -> (Key.t * 'a) option                   val min_elt_exn : 'a t -> Key.t * 'a                   val max_elt : 'a t -> (Key.t * 'a) option                   val max_elt_exn : 'a t -> Key.t * 'a                   val for_all : 'a t -> f:('-> bool) -> bool                   val for_alli :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val exists : 'a t -> f:('-> bool) -> bool                   val existsi :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val counti :                     'a t -> f:(key:Key.t -> data:'-> bool) -> int                   val split :                     'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                   val fold_range_inclusive :                     'a t ->                     min:Key.t ->                     max:Key.t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val range_to_alist :                     'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                   val closest_key :                     'a t ->                     [ `Greater_or_equal_to                     | `Greater_than                     | `Less_or_equal_to                     | `Less_than ] -> Key.t -> (Key.t * 'a) option                   val nth : 'a t -> int -> (Key.t * 'a) option                   val rank : 'a t -> Key.t -> int option                   val to_tree : 'a t -> 'a t                   val to_sequence :                     ?order:[ `Decreasing_key | `Increasing_key ] ->                     ?keys_greater_or_equal_to:Key.t ->                     ?keys_less_or_equal_to:Key.t ->                     'a t -> (Key.t * 'a) Core_kernel.Sequence.t                   val obs :                     Key.t Core_kernel.Quickcheck.Observer.t ->                     'Core_kernel.Quickcheck.Observer.t ->                     'v t Core_kernel.Quickcheck.Observer.t                   val shrinker :                     Key.t Core_kernel.Quickcheck.Shrinker.t ->                     'Core_kernel.Quickcheck.Shrinker.t ->                     'v t Core_kernel.Quickcheck.Shrinker.t                 end               type 'a t =                   (Key.t, 'a, comparator_witness) Core_kernel.Core_map.t               val t_of_sexp :                 (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val compare : ('-> '-> int) -> 'a t -> 'a t -> int               val empty : 'a t               val singleton : Key.t -> '-> 'a t               val of_alist :                 (Key.t * 'a) list ->                 [ `Duplicate_key of Key.t | `Ok of 'a t ]               val of_alist_or_error :                 (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t               val of_alist_exn : (Key.t * 'a) list -> 'a t               val of_alist_multi : (Key.t * 'a) list -> 'a list t               val of_alist_fold :                 (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t               val of_alist_reduce :                 (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t               val of_sorted_array :                 (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t               val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t               val of_tree : 'Tree.t -> 'a t               val gen :                 Key.t Core_kernel.Quickcheck.Generator.t ->                 'Core_kernel.Quickcheck.Generator.t ->                 'a t Core_kernel.Quickcheck.Generator.t               val invariants : 'a t -> bool               val is_empty : 'a t -> bool               val length : 'a t -> int               val add : 'a t -> key:Key.t -> data:'-> 'a t               val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t               val remove_multi : 'a list t -> Key.t -> 'a list t               val change :                 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t               val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t               val find : 'a t -> Key.t -> 'a option               val find_exn : 'a t -> Key.t -> 'a               val remove : 'a t -> Key.t -> 'a t               val mem : 'a t -> Key.t -> bool               val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(Key.t -> unit) -> unit               val iter2 :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    unit) ->                 unit               val map : 'a t -> f:('-> 'b) -> 'b t               val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t               val fold :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold_right :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold2 :                 'a t ->                 'b t ->                 init:'->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    '-> 'c) ->                 'c               val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t               val filter_map : 'a t -> f:('-> 'b option) -> 'b t               val filter_mapi :                 'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t               val partition_mapi :                 'a t ->                 f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                 'b t * 'c t               val partition_map :                 'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t               val partitioni_tf :                 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t               val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t               val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int               val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool               val keys : 'a t -> Key.t list               val data : 'a t -> 'a list               val to_alist :                 ?key_order:[ `Decreasing | `Increasing ] ->                 'a t -> (Key.t * 'a) list               val validate :                 name:(Key.t -> string) ->                 'Core_kernel.Validate.check ->                 'a t Core_kernel.Validate.check               val merge :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    'c option) ->                 'c t               val symmetric_diff :                 'a t ->                 'a t ->                 data_equal:('-> '-> bool) ->                 (Key.t, 'a)                 Core_kernel.Core_map_intf.Symmetric_diff_element.t                 Core_kernel.Sequence.t               val min_elt : 'a t -> (Key.t * 'a) option               val min_elt_exn : 'a t -> Key.t * 'a               val max_elt : 'a t -> (Key.t * 'a) option               val max_elt_exn : 'a t -> Key.t * 'a               val for_all : 'a t -> f:('-> bool) -> bool               val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val exists : 'a t -> f:('-> bool) -> bool               val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int               val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t               val fold_range_inclusive :                 'a t ->                 min:Key.t ->                 max:Key.t ->                 init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val range_to_alist :                 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list               val closest_key :                 'a t ->                 [ `Greater_or_equal_to                 | `Greater_than                 | `Less_or_equal_to                 | `Less_than ] -> Key.t -> (Key.t * 'a) option               val nth : 'a t -> int -> (Key.t * 'a) option               val rank : 'a t -> Key.t -> int option               val to_tree : 'a t -> 'Tree.t               val to_sequence :                 ?order:[ `Decreasing_key | `Increasing_key ] ->                 ?keys_greater_or_equal_to:Key.t ->                 ?keys_less_or_equal_to:Key.t ->                 'a t -> (Key.t * 'a) Core_kernel.Sequence.t               val obs :                 Key.t Core_kernel.Quickcheck.Observer.t ->                 'Core_kernel.Quickcheck.Observer.t ->                 'v t Core_kernel.Quickcheck.Observer.t               val shrinker :                 Key.t Core_kernel.Quickcheck.Shrinker.t ->                 'Core_kernel.Quickcheck.Shrinker.t ->                 'v t Core_kernel.Quickcheck.Shrinker.t             end           module Set :             sig               module Elt :                 sig                   type t = Map.Key.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   type comparator_witness = Map.Key.comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type t =                       (Elt.t, comparator_witness) Core_kernel.Core_set.Tree.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val length : t -> int                   val is_empty : t -> bool                   val iter : t -> f:(Elt.t -> unit) -> unit                   val fold :                     t ->                     init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                   val exists : t -> f:(Elt.t -> bool) -> bool                   val for_all : t -> f:(Elt.t -> bool) -> bool                   val count : t -> f:(Elt.t -> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     t -> f:(Elt.t -> 'sum) -> 'sum                   val find : t -> f:(Elt.t -> bool) -> Elt.t option                   val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                   val to_list : t -> Elt.t list                   val to_array : t -> Elt.t array                   val invariants : t -> bool                   val mem : t -> Elt.t -> bool                   val add : t -> Elt.t -> t                   val remove : t -> Elt.t -> t                   val union : t -> t -> t                   val inter : t -> t -> t                   val diff : t -> t -> t                   val symmetric_diff :                     t ->                     t ->                     (Elt.t, Elt.t) Core_kernel.Either.t                     Core_kernel.Sequence.t                   val compare_direct : t -> t -> int                   val equal : t -> t -> bool                   val subset : t -> t -> bool                   val fold_until :                     t ->                     init:'->                     f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                     'b                   val fold_right :                     t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                   val iter2 :                     t ->                     t ->                     f:([ `Both of Elt.t * Elt.t                        | `Left of Elt.t                        | `Right of Elt.t ] -> unit) ->                     unit                   val filter : t -> f:(Elt.t -> bool) -> t                   val partition_tf : t -> f:(Elt.t -> bool) -> t * t                   val elements : t -> Elt.t list                   val min_elt : t -> Elt.t option                   val min_elt_exn : t -> Elt.t                   val max_elt : t -> Elt.t option                   val max_elt_exn : t -> Elt.t                   val choose : t -> Elt.t option                   val choose_exn : t -> Elt.t                   val split : t -> Elt.t -> t * Elt.t option * t                   val group_by :                     t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                   val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                   val find_index : t -> int -> Elt.t option                   val remove_index : t -> int -> t                   val to_tree : t -> t                   val to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t -> Elt.t Core_kernel.Sequence.t                   val merge_to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t ->                     t ->                     Elt.t                     Core_kernel.Core_set_intf.Merge_to_sequence_element.t                     Core_kernel.Sequence.t                   val to_map :                     t ->                     f:(Elt.t -> 'data) ->                     (Elt.t, 'data, comparator_witness)                     Core_kernel.Core_set_intf.Map.t                   val obs :                     Elt.t Core_kernel.Quickcheck.obs ->                     t Core_kernel.Quickcheck.obs                   val shrinker :                     Elt.t Core_kernel.Quickcheck.shr ->                     t Core_kernel.Quickcheck.shr                   val empty : t                   val singleton : Elt.t -> t                   val union_list : t list -> t                   val of_list : Elt.t list -> t                   val of_array : Elt.t array -> t                   val of_sorted_array :                     Elt.t array -> t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : Elt.t array -> t                   val stable_dedup_list : Elt.t list -> Elt.t list                   val map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t) -> t                   val filter_map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t option) -> t                   val of_tree : t -> t                   val of_map_keys :                     (Elt.t, 'a, comparator_witness)                     Core_kernel.Core_set_intf.Map.t -> t                   val gen :                     Elt.t Core_kernel.Quickcheck.Generator.t ->                     t Core_kernel.Quickcheck.Generator.t                 end               type t = (Elt.t, comparator_witness) Core_kernel.Core_set.t               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               val compare : t -> t -> int               val length : t -> int               val is_empty : t -> bool               val iter : t -> f:(Elt.t -> unit) -> unit               val fold :                 t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum               val exists : t -> f:(Elt.t -> bool) -> bool               val for_all : t -> f:(Elt.t -> bool) -> bool               val count : t -> f:(Elt.t -> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 t -> f:(Elt.t -> 'sum) -> 'sum               val find : t -> f:(Elt.t -> bool) -> Elt.t option               val find_map : t -> f:(Elt.t -> 'a option) -> 'a option               val to_list : t -> Elt.t list               val to_array : t -> Elt.t array               val invariants : t -> bool               val mem : t -> Elt.t -> bool               val add : t -> Elt.t -> t               val remove : t -> Elt.t -> t               val union : t -> t -> t               val inter : t -> t -> t               val diff : t -> t -> t               val symmetric_diff :                 t ->                 t ->                 (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t               val compare_direct : t -> t -> int               val equal : t -> t -> bool               val subset : t -> t -> bool               val fold_until :                 t ->                 init:'->                 f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b               val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b               val iter2 :                 t ->                 t ->                 f:([ `Both of Elt.t * Elt.t                    | `Left of Elt.t                    | `Right of Elt.t ] -> unit) ->                 unit               val filter : t -> f:(Elt.t -> bool) -> t               val partition_tf : t -> f:(Elt.t -> bool) -> t * t               val elements : t -> Elt.t list               val min_elt : t -> Elt.t option               val min_elt_exn : t -> Elt.t               val max_elt : t -> Elt.t option               val max_elt_exn : t -> Elt.t               val choose : t -> Elt.t option               val choose_exn : t -> Elt.t               val split : t -> Elt.t -> t * Elt.t option * t               val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list               val find_exn : t -> f:(Elt.t -> bool) -> Elt.t               val find_index : t -> int -> Elt.t option               val remove_index : t -> int -> t               val to_tree : t -> Tree.t               val to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t               val merge_to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t ->                 t ->                 t ->                 Elt.t Core_kernel.Core_set_intf.Merge_to_sequence_element.t                 Core_kernel.Sequence.t               val to_map :                 t ->                 f:(Elt.t -> 'data) ->                 (Elt.t, 'data, comparator_witness)                 Core_kernel.Core_set_intf.Map.t               val obs :                 Elt.t Core_kernel.Quickcheck.obs ->                 t Core_kernel.Quickcheck.obs               val shrinker :                 Elt.t Core_kernel.Quickcheck.shr ->                 t Core_kernel.Quickcheck.shr               val empty : t               val singleton : Elt.t -> t               val union_list : t list -> t               val of_list : Elt.t list -> t               val of_array : Elt.t array -> t               val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t               val of_sorted_array_unchecked : Elt.t array -> t               val stable_dedup_list : Elt.t list -> Elt.t list               val map :                 ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t               val filter_map :                 ('a, 'b) Core_kernel.Core_set.t ->                 f:('-> Elt.t option) -> t               val of_tree : Tree.t -> t               val of_map_keys :                 (Elt.t, 'a, comparator_witness)                 Core_kernel.Core_set_intf.Map.t -> t               val gen :                 Elt.t Core_kernel.Quickcheck.Generator.t ->                 t Core_kernel.Quickcheck.Generator.t             end           val hash : t -> int           val compare : t -> t -> int           val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t           module Table :             sig               type key = t               type ('a, 'b) hashtbl =                   ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t               type 'b t = (key, 'b) hashtbl               val t_of_sexp :                 (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t               type ('a, 'b) t_ = 'b t               type 'a key_ = key               val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t               val invariant :                 'Core_kernel.Invariant_intf.inv ->                 'a t Core_kernel.Invariant_intf.inv               val create :                 (key, 'b, unit -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist :                 (key, 'b,                  (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_report_all_dups :                 (key, 'b,                  (key * 'b) list ->                  [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_or_error :                 (key, 'b, (key * 'b) list -> 'b t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_exn :                 (key, 'b, (key * 'b) list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_multi :                 (key, 'b list, (key * 'b) list -> 'b list t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_mapped :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_or_error :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> 'r t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_exn :                 (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val group :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  combine:('-> '-> 'b) -> 'r list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t               val clear : 'a t -> unit               val copy : 'b t -> 'b t               val fold :                 'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c               val iter_vals : 'b t -> f:('-> unit) -> unit               val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(key -> unit) -> unit               val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit               val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool               val exists : 'b t -> f:('-> bool) -> bool               val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool               val for_all : 'b t -> f:('-> bool) -> bool               val counti : 'b t -> f:(key:key -> data:'-> bool) -> int               val count : 'b t -> f:('-> bool) -> int               val length : 'a t -> int               val is_empty : 'a t -> bool               val mem : 'a t -> key -> bool               val remove : 'a t -> key -> unit               val replace : 'b t -> key:key -> data:'-> unit               val set : 'b t -> key:key -> data:'-> unit               val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]               val add_or_error :                 'b t -> key:key -> data:'-> unit Core_kernel.Or_error.t               val add_exn : 'b t -> key:key -> data:'-> unit               val change : 'b t -> key -> f:('b option -> 'b option) -> unit               val update : 'b t -> key -> f:('b option -> 'b) -> unit               val add_multi : 'b list t -> key:key -> data:'-> unit               val remove_multi : 'a list t -> key -> unit               val map :                 ('c, 'b t -> f:('-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_map :                 ('c, 'b t -> f:('-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter : 'b t -> f:('-> bool) -> 'b t               val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t               val partition_map :                 ('c,                  ('d,                   'b t ->                   f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_mapi :                 ('c,                  ('d,                   'b t ->                   f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                   'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t               val partitioni_tf :                 'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t               val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b               val find : 'b t -> key -> 'b option               val find_exn : 'b t -> key -> 'b               val find_and_call :                 'b t ->                 key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c               val find_and_remove : 'b t -> key -> 'b option               val merge :                 ('c,                  'a t ->                  'b t ->                  f:(key:key ->                     [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                     'c option) ->                  'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               type 'a merge_into_action = Remove | Set_to of 'a               val merge_into :                 src:'a t ->                 dst:'b t ->                 f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                 unit               val keys : 'a t -> key list               val data : 'b t -> 'b list               val filter_inplace : 'b t -> f:('-> bool) -> unit               val filteri_inplace :                 'b t -> f:(key:key -> data:'-> bool) -> unit               val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit               val map_inplace : 'b t -> f:('-> 'b) -> unit               val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit               val filter_mapi_inplace :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val replace_all : 'b t -> f:('-> 'b) -> unit               val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_replace_all : 'b t -> f:('-> 'b option) -> unit               val filter_replace_alli :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool               val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool               val to_alist : 'b t -> (key * 'b) list               val validate :                 name:(key -> string) ->                 'Core_kernel.Validate.check ->                 'b t Core_kernel.Validate.check               val incr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit               val decr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit             end           module Hash_set :             sig               type elt = t               type 'a hash_set = 'Core_kernel.Hash_set.t               type t = elt hash_set               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               type 'a t_ = t               type 'a elt_ = elt               val create :                 ('a, unit -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable               val of_list :                 ('a, elt list -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable             end           module Hash_queue :             sig               module Key :                 sig                   type t = Hash_set.elt                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val hash : t -> int                 end               type 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val length : 'a t -> int               val is_empty : 'a t -> bool               val iter : 'a t -> f:('-> unit) -> unit               val fold :                 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum               val exists : 'a t -> f:('-> bool) -> bool               val for_all : 'a t -> f:('-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 'a t -> f:('-> 'sum) -> 'sum               val find : 'a t -> f:('-> bool) -> 'a option               val find_map : 'a t -> f:('-> 'b option) -> 'b option               val to_list : 'a t -> 'a list               val to_array : 'a t -> 'a array               val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val invariant : 'a t -> unit               val create : ?growth_allowed:bool -> ?size:int -> unit -> 'a t               val clear : 'a t -> unit               val mem : 'a t -> Key.t -> bool               val lookup : 'a t -> Key.t -> 'a option               val lookup_exn : 'a t -> Key.t -> 'a               val enqueue :                 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]               val enqueue_exn : 'a t -> Key.t -> '-> unit               val first : 'a t -> 'a option               val first_with_key : 'a t -> (Key.t * 'a) option               val keys : 'a t -> Key.t list               val dequeue : 'a t -> 'a option               val dequeue_exn : 'a t -> 'a               val dequeue_with_key : 'a t -> (Key.t * 'a) option               val dequeue_with_key_exn : 'a t -> Key.t * 'a               val dequeue_all : 'a t -> f:('-> unit) -> unit               val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]               val remove_exn : 'a t -> Key.t -> unit               val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]               val replace_exn : 'a t -> Key.t -> '-> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val foldi :                 'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b             end         end       module type Edge =         sig           type t           type node           type graph           type label           val create :             Graphlib.Std.Edge.node ->             Graphlib.Std.Edge.node ->             Graphlib.Std.Edge.label -> Graphlib.Std.Edge.t           val label : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.label           val src : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.node           val dst : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.node           val mem : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.graph -> bool           val insert :             Graphlib.Std.Edge.t ->             Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph           val update :             Graphlib.Std.Edge.t ->             Graphlib.Std.Edge.label ->             Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph           val remove :             Graphlib.Std.Edge.t ->             Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph           val ( >= ) : t -> t -> bool           val ( <= ) : t -> t -> bool           val ( = ) : t -> t -> bool           val ( > ) : t -> t -> bool           val ( < ) : t -> t -> bool           val ( <> ) : t -> t -> bool           val equal : t -> t -> bool           val min : t -> t -> t           val max : t -> t -> t           val ascending : t -> t -> int           val descending : t -> t -> int           val between : t -> low:t -> high:t -> bool           val clamp_exn : t -> min:t -> max:t -> t           val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t           module Replace_polymorphic_compare :             sig               val ( >= ) : t -> t -> bool               val ( <= ) : t -> t -> bool               val ( = ) : t -> t -> bool               val ( > ) : t -> t -> bool               val ( < ) : t -> t -> bool               val ( <> ) : t -> t -> bool               val equal : t -> t -> bool               val compare : t -> t -> int               val min : t -> t -> t               val max : t -> t -> t             end           type comparator_witness           val comparator :             (t, comparator_witness) Core_kernel.Comparator.comparator           val validate_lbound :             min:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_ubound :             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_bound :             min:t Core_kernel.Maybe_bound.t ->             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           module Map :             sig               module Key :                 sig                   type t = t                   type comparator_witness = comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type 'a t =                       (Key.t, 'a, comparator_witness)                       Core_kernel.Core_map.Tree.t                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val empty : 'a t                   val singleton : Key.t -> '-> 'a t                   val of_alist :                     (Key.t * 'a) list ->                     [ `Duplicate_key of Key.t | `Ok of 'a t ]                   val of_alist_or_error :                     (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                   val of_alist_exn : (Key.t * 'a) list -> 'a t                   val of_alist_multi : (Key.t * 'a) list -> 'a list t                   val of_alist_fold :                     (Key.t * 'a) list ->                     init:'-> f:('-> '-> 'b) -> 'b t                   val of_alist_reduce :                     (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                   val of_sorted_array :                     (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t                   val of_tree : 'a t -> 'a t                   val gen :                     Key.t Core_kernel.Quickcheck.Generator.t ->                     'Core_kernel.Quickcheck.Generator.t ->                     'a t Core_kernel.Quickcheck.Generator.t                   val invariants : 'a t -> bool                   val is_empty : 'a t -> bool                   val length : 'a t -> int                   val add : 'a t -> key:Key.t -> data:'-> 'a t                   val add_multi :                     'a list t -> key:Key.t -> data:'-> 'a list t                   val remove_multi : 'a list t -> Key.t -> 'a list t                   val change :                     'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                   val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                   val find : 'a t -> Key.t -> 'a option                   val find_exn : 'a t -> Key.t -> 'a                   val remove : 'a t -> Key.t -> 'a t                   val mem : 'a t -> Key.t -> bool                   val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iteri :                     'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                   val iter2 :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        unit) ->                     unit                   val map : 'a t -> f:('-> 'b) -> 'b t                   val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                   val fold :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold_right :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold2 :                     'a t ->                     'b t ->                     init:'->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        '-> 'c) ->                     'c                   val filter :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filteri :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                   val filter_map : 'a t -> f:('-> 'b option) -> 'b t                   val filter_mapi :                     'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                   val partition_mapi :                     'a t ->                     f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                     'b t * 'c t                   val partition_map :                     'a t ->                     f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                   val partitioni_tf :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                   val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                   val compare_direct :                     ('-> '-> int) -> 'a t -> 'a t -> int                   val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                   val keys : 'a t -> Key.t list                   val data : 'a t -> 'a list                   val to_alist :                     ?key_order:[ `Decreasing | `Increasing ] ->                     'a t -> (Key.t * 'a) list                   val validate :                     name:(Key.t -> string) ->                     'Core_kernel.Validate.check ->                     'a t Core_kernel.Validate.check                   val merge :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        'c option) ->                     'c t                   val symmetric_diff :                     'a t ->                     'a t ->                     data_equal:('-> '-> bool) ->                     (Key.t, 'a)                     Core_kernel.Core_map_intf.Symmetric_diff_element.t                     Core_kernel.Sequence.t                   val min_elt : 'a t -> (Key.t * 'a) option                   val min_elt_exn : 'a t -> Key.t * 'a                   val max_elt : 'a t -> (Key.t * 'a) option                   val max_elt_exn : 'a t -> Key.t * 'a                   val for_all : 'a t -> f:('-> bool) -> bool                   val for_alli :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val exists : 'a t -> f:('-> bool) -> bool                   val existsi :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val counti :                     'a t -> f:(key:Key.t -> data:'-> bool) -> int                   val split :                     'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                   val fold_range_inclusive :                     'a t ->                     min:Key.t ->                     max:Key.t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val range_to_alist :                     'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                   val closest_key :                     'a t ->                     [ `Greater_or_equal_to                     | `Greater_than                     | `Less_or_equal_to                     | `Less_than ] -> Key.t -> (Key.t * 'a) option                   val nth : 'a t -> int -> (Key.t * 'a) option                   val rank : 'a t -> Key.t -> int option                   val to_tree : 'a t -> 'a t                   val to_sequence :                     ?order:[ `Decreasing_key | `Increasing_key ] ->                     ?keys_greater_or_equal_to:Key.t ->                     ?keys_less_or_equal_to:Key.t ->                     'a t -> (Key.t * 'a) Core_kernel.Sequence.t                   val obs :                     Key.t Core_kernel.Quickcheck.Observer.t ->                     'Core_kernel.Quickcheck.Observer.t ->                     'v t Core_kernel.Quickcheck.Observer.t                   val shrinker :                     Key.t Core_kernel.Quickcheck.Shrinker.t ->                     'Core_kernel.Quickcheck.Shrinker.t ->                     'v t Core_kernel.Quickcheck.Shrinker.t                 end               type 'a t =                   (Key.t, 'a, comparator_witness) Core_kernel.Core_map.t               val t_of_sexp :                 (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val compare : ('-> '-> int) -> 'a t -> 'a t -> int               val empty : 'a t               val singleton : Key.t -> '-> 'a t               val of_alist :                 (Key.t * 'a) list ->                 [ `Duplicate_key of Key.t | `Ok of 'a t ]               val of_alist_or_error :                 (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t               val of_alist_exn : (Key.t * 'a) list -> 'a t               val of_alist_multi : (Key.t * 'a) list -> 'a list t               val of_alist_fold :                 (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t               val of_alist_reduce :                 (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t               val of_sorted_array :                 (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t               val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t               val of_tree : 'Tree.t -> 'a t               val gen :                 Key.t Core_kernel.Quickcheck.Generator.t ->                 'Core_kernel.Quickcheck.Generator.t ->                 'a t Core_kernel.Quickcheck.Generator.t               val invariants : 'a t -> bool               val is_empty : 'a t -> bool               val length : 'a t -> int               val add : 'a t -> key:Key.t -> data:'-> 'a t               val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t               val remove_multi : 'a list t -> Key.t -> 'a list t               val change :                 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t               val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t               val find : 'a t -> Key.t -> 'a option               val find_exn : 'a t -> Key.t -> 'a               val remove : 'a t -> Key.t -> 'a t               val mem : 'a t -> Key.t -> bool               val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(Key.t -> unit) -> unit               val iter2 :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    unit) ->                 unit               val map : 'a t -> f:('-> 'b) -> 'b t               val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t               val fold :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold_right :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold2 :                 'a t ->                 'b t ->                 init:'->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    '-> 'c) ->                 'c               val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t               val filter_map : 'a t -> f:('-> 'b option) -> 'b t               val filter_mapi :                 'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t               val partition_mapi :                 'a t ->                 f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                 'b t * 'c t               val partition_map :                 'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t               val partitioni_tf :                 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t               val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t               val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int               val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool               val keys : 'a t -> Key.t list               val data : 'a t -> 'a list               val to_alist :                 ?key_order:[ `Decreasing | `Increasing ] ->                 'a t -> (Key.t * 'a) list               val validate :                 name:(Key.t -> string) ->                 'Core_kernel.Validate.check ->                 'a t Core_kernel.Validate.check               val merge :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    'c option) ->                 'c t               val symmetric_diff :                 'a t ->                 'a t ->                 data_equal:('-> '-> bool) ->                 (Key.t, 'a)                 Core_kernel.Core_map_intf.Symmetric_diff_element.t                 Core_kernel.Sequence.t               val min_elt : 'a t -> (Key.t * 'a) option               val min_elt_exn : 'a t -> Key.t * 'a               val max_elt : 'a t -> (Key.t * 'a) option               val max_elt_exn : 'a t -> Key.t * 'a               val for_all : 'a t -> f:('-> bool) -> bool               val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val exists : 'a t -> f:('-> bool) -> bool               val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int               val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t               val fold_range_inclusive :                 'a t ->                 min:Key.t ->                 max:Key.t ->                 init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val range_to_alist :                 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list               val closest_key :                 'a t ->                 [ `Greater_or_equal_to                 | `Greater_than                 | `Less_or_equal_to                 | `Less_than ] -> Key.t -> (Key.t * 'a) option               val nth : 'a t -> int -> (Key.t * 'a) option               val rank : 'a t -> Key.t -> int option               val to_tree : 'a t -> 'Tree.t               val to_sequence :                 ?order:[ `Decreasing_key | `Increasing_key ] ->                 ?keys_greater_or_equal_to:Key.t ->                 ?keys_less_or_equal_to:Key.t ->                 'a t -> (Key.t * 'a) Core_kernel.Sequence.t               val obs :                 Key.t Core_kernel.Quickcheck.Observer.t ->                 'Core_kernel.Quickcheck.Observer.t ->                 'v t Core_kernel.Quickcheck.Observer.t               val shrinker :                 Key.t Core_kernel.Quickcheck.Shrinker.t ->                 'Core_kernel.Quickcheck.Shrinker.t ->                 'v t Core_kernel.Quickcheck.Shrinker.t             end           module Set :             sig               module Elt :                 sig                   type t = Map.Key.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   type comparator_witness = Map.Key.comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type t =                       (Elt.t, comparator_witness) Core_kernel.Core_set.Tree.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val length : t -> int                   val is_empty : t -> bool                   val iter : t -> f:(Elt.t -> unit) -> unit                   val fold :                     t ->                     init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                   val exists : t -> f:(Elt.t -> bool) -> bool                   val for_all : t -> f:(Elt.t -> bool) -> bool                   val count : t -> f:(Elt.t -> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     t -> f:(Elt.t -> 'sum) -> 'sum                   val find : t -> f:(Elt.t -> bool) -> Elt.t option                   val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                   val to_list : t -> Elt.t list                   val to_array : t -> Elt.t array                   val invariants : t -> bool                   val mem : t -> Elt.t -> bool                   val add : t -> Elt.t -> t                   val remove : t -> Elt.t -> t                   val union : t -> t -> t                   val inter : t -> t -> t                   val diff : t -> t -> t                   val symmetric_diff :                     t ->                     t ->                     (Elt.t, Elt.t) Core_kernel.Either.t                     Core_kernel.Sequence.t                   val compare_direct : t -> t -> int                   val equal : t -> t -> bool                   val subset : t -> t -> bool                   val fold_until :                     t ->                     init:'->                     f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                     'b                   val fold_right :                     t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                   val iter2 :                     t ->                     t ->                     f:([ `Both of Elt.t * Elt.t                        | `Left of Elt.t                        | `Right of Elt.t ] -> unit) ->                     unit                   val filter : t -> f:(Elt.t -> bool) -> t                   val partition_tf : t -> f:(Elt.t -> bool) -> t * t                   val elements : t -> Elt.t list                   val min_elt : t -> Elt.t option                   val min_elt_exn : t -> Elt.t                   val max_elt : t -> Elt.t option                   val max_elt_exn : t -> Elt.t                   val choose : t -> Elt.t option                   val choose_exn : t -> Elt.t                   val split : t -> Elt.t -> t * Elt.t option * t                   val group_by :                     t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                   val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                   val find_index : t -> int -> Elt.t option                   val remove_index : t -> int -> t                   val to_tree : t -> t                   val to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t -> Elt.t Core_kernel.Sequence.t                   val merge_to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t ->                     t ->                     Elt.t                     Core_kernel.Core_set_intf.Merge_to_sequence_element.t                     Core_kernel.Sequence.t                   val to_map :                     t ->                     f:(Elt.t -> 'data) ->                     (Elt.t, 'data, comparator_witness)                     Core_kernel.Core_set_intf.Map.t                   val obs :                     Elt.t Core_kernel.Quickcheck.obs ->                     t Core_kernel.Quickcheck.obs                   val shrinker :                     Elt.t Core_kernel.Quickcheck.shr ->                     t Core_kernel.Quickcheck.shr                   val empty : t                   val singleton : Elt.t -> t                   val union_list : t list -> t                   val of_list : Elt.t list -> t                   val of_array : Elt.t array -> t                   val of_sorted_array :                     Elt.t array -> t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : Elt.t array -> t                   val stable_dedup_list : Elt.t list -> Elt.t list                   val map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t) -> t                   val filter_map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t option) -> t                   val of_tree : t -> t                   val of_map_keys :                     (Elt.t, 'a, comparator_witness)                     Core_kernel.Core_set_intf.Map.t -> t                   val gen :                     Elt.t Core_kernel.Quickcheck.Generator.t ->                     t Core_kernel.Quickcheck.Generator.t                 end               type t = (Elt.t, comparator_witness) Core_kernel.Core_set.t               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               val compare : t -> t -> int               val length : t -> int               val is_empty : t -> bool               val iter : t -> f:(Elt.t -> unit) -> unit               val fold :                 t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum               val exists : t -> f:(Elt.t -> bool) -> bool               val for_all : t -> f:(Elt.t -> bool) -> bool               val count : t -> f:(Elt.t -> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 t -> f:(Elt.t -> 'sum) -> 'sum               val find : t -> f:(Elt.t -> bool) -> Elt.t option               val find_map : t -> f:(Elt.t -> 'a option) -> 'a option               val to_list : t -> Elt.t list               val to_array : t -> Elt.t array               val invariants : t -> bool               val mem : t -> Elt.t -> bool               val add : t -> Elt.t -> t               val remove : t -> Elt.t -> t               val union : t -> t -> t               val inter : t -> t -> t               val diff : t -> t -> t               val symmetric_diff :                 t ->                 t ->                 (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t               val compare_direct : t -> t -> int               val equal : t -> t -> bool               val subset : t -> t -> bool               val fold_until :                 t ->                 init:'->                 f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b               val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b               val iter2 :                 t ->                 t ->                 f:([ `Both of Elt.t * Elt.t                    | `Left of Elt.t                    | `Right of Elt.t ] -> unit) ->                 unit               val filter : t -> f:(Elt.t -> bool) -> t               val partition_tf : t -> f:(Elt.t -> bool) -> t * t               val elements : t -> Elt.t list               val min_elt : t -> Elt.t option               val min_elt_exn : t -> Elt.t               val max_elt : t -> Elt.t option               val max_elt_exn : t -> Elt.t               val choose : t -> Elt.t option               val choose_exn : t -> Elt.t               val split : t -> Elt.t -> t * Elt.t option * t               val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list               val find_exn : t -> f:(Elt.t -> bool) -> Elt.t               val find_index : t -> int -> Elt.t option               val remove_index : t -> int -> t               val to_tree : t -> Tree.t               val to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t               val merge_to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t ->                 t ->                 t ->                 Elt.t Core_kernel.Core_set_intf.Merge_to_sequence_element.t                 Core_kernel.Sequence.t               val to_map :                 t ->                 f:(Elt.t -> 'data) ->                 (Elt.t, 'data, comparator_witness)                 Core_kernel.Core_set_intf.Map.t               val obs :                 Elt.t Core_kernel.Quickcheck.obs ->                 t Core_kernel.Quickcheck.obs               val shrinker :                 Elt.t Core_kernel.Quickcheck.shr ->                 t Core_kernel.Quickcheck.shr               val empty : t               val singleton : Elt.t -> t               val union_list : t list -> t               val of_list : Elt.t list -> t               val of_array : Elt.t array -> t               val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t               val of_sorted_array_unchecked : Elt.t array -> t               val stable_dedup_list : Elt.t list -> Elt.t list               val map :                 ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t               val filter_map :                 ('a, 'b) Core_kernel.Core_set.t ->                 f:('-> Elt.t option) -> t               val of_tree : Tree.t -> t               val of_map_keys :                 (Elt.t, 'a, comparator_witness)                 Core_kernel.Core_set_intf.Map.t -> t               val gen :                 Elt.t Core_kernel.Quickcheck.Generator.t ->                 t Core_kernel.Quickcheck.Generator.t             end           val hash : t -> int           val compare : t -> t -> int           val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t           module Table :             sig               type key = t               type ('a, 'b) hashtbl =                   ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t               type 'b t = (key, 'b) hashtbl               val t_of_sexp :                 (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t               type ('a, 'b) t_ = 'b t               type 'a key_ = key               val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t               val invariant :                 'Core_kernel.Invariant_intf.inv ->                 'a t Core_kernel.Invariant_intf.inv               val create :                 (key, 'b, unit -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist :                 (key, 'b,                  (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_report_all_dups :                 (key, 'b,                  (key * 'b) list ->                  [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_or_error :                 (key, 'b, (key * 'b) list -> 'b t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_exn :                 (key, 'b, (key * 'b) list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_multi :                 (key, 'b list, (key * 'b) list -> 'b list t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_mapped :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_or_error :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> 'r t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_exn :                 (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val group :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  combine:('-> '-> 'b) -> 'r list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t               val clear : 'a t -> unit               val copy : 'b t -> 'b t               val fold :                 'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c               val iter_vals : 'b t -> f:('-> unit) -> unit               val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(key -> unit) -> unit               val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit               val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool               val exists : 'b t -> f:('-> bool) -> bool               val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool               val for_all : 'b t -> f:('-> bool) -> bool               val counti : 'b t -> f:(key:key -> data:'-> bool) -> int               val count : 'b t -> f:('-> bool) -> int               val length : 'a t -> int               val is_empty : 'a t -> bool               val mem : 'a t -> key -> bool               val remove : 'a t -> key -> unit               val replace : 'b t -> key:key -> data:'-> unit               val set : 'b t -> key:key -> data:'-> unit               val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]               val add_or_error :                 'b t -> key:key -> data:'-> unit Core_kernel.Or_error.t               val add_exn : 'b t -> key:key -> data:'-> unit               val change : 'b t -> key -> f:('b option -> 'b option) -> unit               val update : 'b t -> key -> f:('b option -> 'b) -> unit               val add_multi : 'b list t -> key:key -> data:'-> unit               val remove_multi : 'a list t -> key -> unit               val map :                 ('c, 'b t -> f:('-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_map :                 ('c, 'b t -> f:('-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter : 'b t -> f:('-> bool) -> 'b t               val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t               val partition_map :                 ('c,                  ('d,                   'b t ->                   f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_mapi :                 ('c,                  ('d,                   'b t ->                   f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                   'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t               val partitioni_tf :                 'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t               val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b               val find : 'b t -> key -> 'b option               val find_exn : 'b t -> key -> 'b               val find_and_call :                 'b t ->                 key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c               val find_and_remove : 'b t -> key -> 'b option               val merge :                 ('c,                  'a t ->                  'b t ->                  f:(key:key ->                     [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                     'c option) ->                  'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               type 'a merge_into_action = Remove | Set_to of 'a               val merge_into :                 src:'a t ->                 dst:'b t ->                 f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                 unit               val keys : 'a t -> key list               val data : 'b t -> 'b list               val filter_inplace : 'b t -> f:('-> bool) -> unit               val filteri_inplace :                 'b t -> f:(key:key -> data:'-> bool) -> unit               val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit               val map_inplace : 'b t -> f:('-> 'b) -> unit               val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit               val filter_mapi_inplace :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val replace_all : 'b t -> f:('-> 'b) -> unit               val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_replace_all : 'b t -> f:('-> 'b option) -> unit               val filter_replace_alli :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool               val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool               val to_alist : 'b t -> (key * 'b) list               val validate :                 name:(key -> string) ->                 'Core_kernel.Validate.check ->                 'b t Core_kernel.Validate.check               val incr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit               val decr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit             end           module Hash_set :             sig               type elt = t               type 'a hash_set = 'Core_kernel.Hash_set.t               type t = elt hash_set               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               type 'a t_ = t               type 'a elt_ = elt               val create :                 ('a, unit -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable               val of_list :                 ('a, elt list -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable             end           module Hash_queue :             sig               module Key :                 sig                   type t = Hash_set.elt                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val hash : t -> int                 end               type 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val length : 'a t -> int               val is_empty : 'a t -> bool               val iter : 'a t -> f:('-> unit) -> unit               val fold :                 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum               val exists : 'a t -> f:('-> bool) -> bool               val for_all : 'a t -> f:('-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 'a t -> f:('-> 'sum) -> 'sum               val find : 'a t -> f:('-> bool) -> 'a option               val find_map : 'a t -> f:('-> 'b option) -> 'b option               val to_list : 'a t -> 'a list               val to_array : 'a t -> 'a array               val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val invariant : 'a t -> unit               val create : ?growth_allowed:bool -> ?size:int -> unit -> 'a t               val clear : 'a t -> unit               val mem : 'a t -> Key.t -> bool               val lookup : 'a t -> Key.t -> 'a option               val lookup_exn : 'a t -> Key.t -> 'a               val enqueue :                 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]               val enqueue_exn : 'a t -> Key.t -> '-> unit               val first : 'a t -> 'a option               val first_with_key : 'a t -> (Key.t * 'a) option               val keys : 'a t -> Key.t list               val dequeue : 'a t -> 'a option               val dequeue_exn : 'a t -> 'a               val dequeue_with_key : 'a t -> (Key.t * 'a) option               val dequeue_with_key_exn : 'a t -> Key.t * 'a               val dequeue_all : 'a t -> f:('-> unit) -> unit               val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]               val remove_exn : 'a t -> Key.t -> unit               val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]               val replace_exn : 'a t -> Key.t -> '-> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val foldi :                 'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b             end         end       module type Graph =         sig           type t           type node           type edge           module Node :             sig               type t = node               type graph = t               type label               type edge = edge               val create : label -> t               val label : t -> label               val mem : t -> graph -> bool               val succs : t -> graph -> t Regular.Std.seq               val preds : t -> graph -> t Regular.Std.seq               val inputs : t -> graph -> edge Regular.Std.seq               val outputs : t -> graph -> edge Regular.Std.seq               val degree : ?dir:[ `In | `Out ] -> t -> graph -> int               val insert : t -> graph -> graph               val update : t -> label -> graph -> graph               val remove : t -> graph -> graph               val has_edge : t -> t -> graph -> bool               val edge : t -> t -> graph -> edge option               val ( >= ) : t -> t -> bool               val ( <= ) : t -> t -> bool               val ( = ) : t -> t -> bool               val ( > ) : t -> t -> bool               val ( < ) : t -> t -> bool               val ( <> ) : t -> t -> bool               val equal : t -> t -> bool               val min : t -> t -> t               val max : t -> t -> t               val ascending : t -> t -> int               val descending : t -> t -> int               val between : t -> low:t -> high:t -> bool               val clamp_exn : t -> min:t -> max:t -> t               val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t               module Replace_polymorphic_compare :                 sig                   val ( >= ) : t -> t -> bool                   val ( <= ) : t -> t -> bool                   val ( = ) : t -> t -> bool                   val ( > ) : t -> t -> bool                   val ( < ) : t -> t -> bool                   val ( <> ) : t -> t -> bool                   val equal : t -> t -> bool                   val compare : t -> t -> int                   val min : t -> t -> t                   val max : t -> t -> t                 end               type comparator_witness               val comparator :                 (t, comparator_witness) Core_kernel.Comparator.comparator               val validate_lbound :                 min:t Core_kernel.Maybe_bound.t ->                 t Core_kernel.Validate.check               val validate_ubound :                 max:t Core_kernel.Maybe_bound.t ->                 t Core_kernel.Validate.check               val validate_bound :                 min:t Core_kernel.Maybe_bound.t ->                 max:t Core_kernel.Maybe_bound.t ->                 t Core_kernel.Validate.check               module Map :                 sig                   module Key :                     sig                       type t = node                       type comparator_witness = comparator_witness                       val comparator :                         (t, comparator_witness)                         Core_kernel.Comparator.comparator                     end                   module Tree :                     sig                       type 'a t =                           (node, 'a, comparator_witness)                           Core_kernel.Core_map.Tree.t                       val t_of_sexp :                         (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                       val sexp_of_t :                         ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                       val empty : 'a t                       val singleton : node -> '-> 'a t                       val of_alist :                         (node * 'a) list ->                         [ `Duplicate_key of node | `Ok of 'a t ]                       val of_alist_or_error :                         (node * 'a) list -> 'a t Core_kernel.Or_error.t                       val of_alist_exn : (node * 'a) list -> 'a t                       val of_alist_multi : (node * 'a) list -> 'a list t                       val of_alist_fold :                         (node * 'a) list ->                         init:'-> f:('-> '-> 'b) -> 'b t                       val of_alist_reduce :                         (node * 'a) list -> f:('-> '-> 'a) -> 'a t                       val of_sorted_array :                         (node * 'a) array -> 'a t Core_kernel.Or_error.t                       val of_sorted_array_unchecked :                         (node * 'a) array -> 'a t                       val of_tree : 'a t -> 'a t                       val gen :                         node Core_kernel.Quickcheck.Generator.t ->                         'Core_kernel.Quickcheck.Generator.t ->                         'a t Core_kernel.Quickcheck.Generator.t                       val invariants : 'a t -> bool                       val is_empty : 'a t -> bool                       val length : 'a t -> int                       val add : 'a t -> key:node -> data:'-> 'a t                       val add_multi :                         'a list t -> key:node -> data:'-> 'a list t                       val remove_multi : 'a list t -> node -> 'a list t                       val change :                         'a t -> node -> f:('a option -> 'a option) -> 'a t                       val update :                         'a t -> node -> f:('a option -> 'a) -> 'a t                       val find : 'a t -> node -> 'a option                       val find_exn : 'a t -> node -> 'a                       val remove : 'a t -> node -> 'a t                       val mem : 'a t -> node -> bool                       val iter :                         'a t -> f:(key:node -> data:'-> unit) -> unit                       val iteri :                         'a t -> f:(key:node -> data:'-> unit) -> unit                       val iter_keys : 'a t -> f:(node -> unit) -> unit                       val iter2 :                         'a t ->                         'b t ->                         f:(key:node ->                            data:[ `Both of 'a * 'b                                 | `Left of 'a                                 | `Right of 'b ] ->                            unit) ->                         unit                       val map : 'a t -> f:('-> 'b) -> 'b t                       val mapi :                         'a t -> f:(key:node -> data:'-> 'b) -> 'b t                       val fold :                         'a t ->                         init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b                       val fold_right :                         'a t ->                         init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b                       val fold2 :                         'a t ->                         'b t ->                         init:'->                         f:(key:node ->                            data:[ `Both of 'a * 'b                                 | `Left of 'a                                 | `Right of 'b ] ->                            '-> 'c) ->                         'c                       val filter :                         'a t -> f:(key:node -> data:'-> bool) -> 'a t                       val filteri :                         'a t -> f:(key:node -> data:'-> bool) -> 'a t                       val filter_keys : 'a t -> f:(node -> bool) -> 'a t                       val filter_map : 'a t -> f:('-> 'b option) -> 'b t                       val filter_mapi :                         'a t -> f:(key:node -> data:'-> 'b option) -> 'b t                       val partition_mapi :                         'a t ->                         f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                         'b t * 'c t                       val partition_map :                         'a t ->                         f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                       val partitioni_tf :                         'a t ->                         f:(key:node -> data:'-> bool) -> 'a t * 'a t                       val partition_tf :                         'a t -> f:('-> bool) -> 'a t * 'a t                       val compare_direct :                         ('-> '-> int) -> 'a t -> 'a t -> int                       val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                       val keys : 'a t -> node list                       val data : 'a t -> 'a list                       val to_alist :                         ?key_order:[ `Decreasing | `Increasing ] ->                         'a t -> (node * 'a) list                       val validate :                         name:(node -> string) ->                         'Core_kernel.Validate.check ->                         'a t Core_kernel.Validate.check                       val merge :                         'a t ->                         'b t ->                         f:(key:node ->                            [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                            'c option) ->                         'c t                       val symmetric_diff :                         'a t ->                         'a t ->                         data_equal:('-> '-> bool) ->                         (node, 'a)                         Core_kernel.Core_map_intf.Symmetric_diff_element.t                         Core_kernel.Sequence.t                       val min_elt : 'a t -> (node * 'a) option                       val min_elt_exn : 'a t -> node * 'a                       val max_elt : 'a t -> (node * 'a) option                       val max_elt_exn : 'a t -> node * 'a                       val for_all : 'a t -> f:('-> bool) -> bool                       val for_alli :                         'a t -> f:(key:node -> data:'-> bool) -> bool                       val exists : 'a t -> f:('-> bool) -> bool                       val existsi :                         'a t -> f:(key:node -> data:'-> bool) -> bool                       val count : 'a t -> f:('-> bool) -> int                       val counti :                         'a t -> f:(key:node -> data:'-> bool) -> int                       val split :                         'a t -> node -> 'a t * (node * 'a) option * 'a t                       val fold_range_inclusive :                         'a t ->                         min:node ->                         max:node ->                         init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b                       val range_to_alist :                         'a t -> min:node -> max:node -> (node * 'a) list                       val closest_key :                         'a t ->                         [ `Greater_or_equal_to                         | `Greater_than                         | `Less_or_equal_to                         | `Less_than ] -> node -> (node * 'a) option                       val nth : 'a t -> int -> (node * 'a) option                       val rank : 'a t -> node -> int option                       val to_tree : 'a t -> 'a t                       val to_sequence :                         ?order:[ `Decreasing_key | `Increasing_key ] ->                         ?keys_greater_or_equal_to:node ->                         ?keys_less_or_equal_to:node ->                         'a t -> (node * 'a) Core_kernel.Sequence.t                       val obs :                         node Core_kernel.Quickcheck.Observer.t ->                         'Core_kernel.Quickcheck.Observer.t ->                         'v t Core_kernel.Quickcheck.Observer.t                       val shrinker :                         node Core_kernel.Quickcheck.Shrinker.t ->                         'Core_kernel.Quickcheck.Shrinker.t ->                         'v t Core_kernel.Quickcheck.Shrinker.t                     end                   type 'a t =                       (node, 'a, comparator_witness) Core_kernel.Core_map.t                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val compare : ('-> '-> int) -> 'a t -> 'a t -> int                   val empty : 'a t                   val singleton : node -> '-> 'a t                   val of_alist :                     (node * 'a) list ->                     [ `Duplicate_key of node | `Ok of 'a t ]                   val of_alist_or_error :                     (node * 'a) list -> 'a t Core_kernel.Or_error.t                   val of_alist_exn : (node * 'a) list -> 'a t                   val of_alist_multi : (node * 'a) list -> 'a list t                   val of_alist_fold :                     (node * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t                   val of_alist_reduce :                     (node * 'a) list -> f:('-> '-> 'a) -> 'a t                   val of_sorted_array :                     (node * 'a) array -> 'a t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : (node * 'a) array -> 'a t                   val of_tree : 'Tree.t -> 'a t                   val gen :                     node Core_kernel.Quickcheck.Generator.t ->                     'Core_kernel.Quickcheck.Generator.t ->                     'a t Core_kernel.Quickcheck.Generator.t                   val invariants : 'a t -> bool                   val is_empty : 'a t -> bool                   val length : 'a t -> int                   val add : 'a t -> key:node -> data:'-> 'a t                   val add_multi :                     'a list t -> key:node -> data:'-> 'a list t                   val remove_multi : 'a list t -> node -> 'a list t                   val change :                     'a t -> node -> f:('a option -> 'a option) -> 'a t                   val update : 'a t -> node -> f:('a option -> 'a) -> 'a t                   val find : 'a t -> node -> 'a option                   val find_exn : 'a t -> node -> 'a                   val remove : 'a t -> node -> 'a t                   val mem : 'a t -> node -> bool                   val iter : 'a t -> f:(key:node -> data:'-> unit) -> unit                   val iteri : 'a t -> f:(key:node -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(node -> unit) -> unit                   val iter2 :                     'a t ->                     'b t ->                     f:(key:node ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        unit) ->                     unit                   val map : 'a t -> f:('-> 'b) -> 'b t                   val mapi : 'a t -> f:(key:node -> data:'-> 'b) -> 'b t                   val fold :                     'a t ->                     init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b                   val fold_right :                     'a t ->                     init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b                   val fold2 :                     'a t ->                     'b t ->                     init:'->                     f:(key:node ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        '-> 'c) ->                     'c                   val filter :                     'a t -> f:(key:node -> data:'-> bool) -> 'a t                   val filteri :                     'a t -> f:(key:node -> data:'-> bool) -> 'a t                   val filter_keys : 'a t -> f:(node -> bool) -> 'a t                   val filter_map : 'a t -> f:('-> 'b option) -> 'b t                   val filter_mapi :                     'a t -> f:(key:node -> data:'-> 'b option) -> 'b t                   val partition_mapi :                     'a t ->                     f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                     'b t * 'c t                   val partition_map :                     'a t ->                     f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                   val partitioni_tf :                     'a t -> f:(key:node -> data:'-> bool) -> 'a t * 'a t                   val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                   val compare_direct :                     ('-> '-> int) -> 'a t -> 'a t -> int                   val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                   val keys : 'a t -> node list                   val data : 'a t -> 'a list                   val to_alist :                     ?key_order:[ `Decreasing | `Increasing ] ->                     'a t -> (node * 'a) list                   val validate :                     name:(node -> string) ->                     'Core_kernel.Validate.check ->                     'a t Core_kernel.Validate.check                   val merge :                     'a t ->                     'b t ->                     f:(key:node ->                        [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        'c option) ->                     'c t                   val symmetric_diff :                     'a t ->                     'a t ->                     data_equal:('-> '-> bool) ->                     (node, 'a)                     Core_kernel.Core_map_intf.Symmetric_diff_element.t                     Core_kernel.Sequence.t                   val min_elt : 'a t -> (node * 'a) option                   val min_elt_exn : 'a t -> node * 'a                   val max_elt : 'a t -> (node * 'a) option                   val max_elt_exn : 'a t -> node * 'a                   val for_all : 'a t -> f:('-> bool) -> bool                   val for_alli :                     'a t -> f:(key:node -> data:'-> bool) -> bool                   val exists : 'a t -> f:('-> bool) -> bool                   val existsi :                     'a t -> f:(key:node -> data:'-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val counti : 'a t -> f:(key:node -> data:'-> bool) -> int                   val split :                     'a t -> node -> 'a t * (node * 'a) option * 'a t                   val fold_range_inclusive :                     'a t ->                     min:node ->                     max:node ->                     init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b                   val range_to_alist :                     'a t -> min:node -> max:node -> (node * 'a) list                   val closest_key :                     'a t ->                     [ `Greater_or_equal_to                     | `Greater_than                     | `Less_or_equal_to                     | `Less_than ] -> node -> (node * 'a) option                   val nth : 'a t -> int -> (node * 'a) option                   val rank : 'a t -> node -> int option                   val to_tree : 'a t -> 'Tree.t                   val to_sequence :                     ?order:[ `Decreasing_key | `Increasing_key ] ->                     ?keys_greater_or_equal_to:node ->                     ?keys_less_or_equal_to:node ->                     'a t -> (node * 'a) Core_kernel.Sequence.t                   val obs :                     node Core_kernel.Quickcheck.Observer.t ->                     'Core_kernel.Quickcheck.Observer.t ->                     'v t Core_kernel.Quickcheck.Observer.t                   val shrinker :                     node Core_kernel.Quickcheck.Shrinker.t ->                     'Core_kernel.Quickcheck.Shrinker.t ->                     'v t Core_kernel.Quickcheck.Shrinker.t                 end               module Set :                 sig                   module Elt :                     sig                       type t = node                       val t_of_sexp : Sexplib.Sexp.t -> t                       val sexp_of_t : t -> Sexplib.Sexp.t                       type comparator_witness = Map.Key.comparator_witness                       val comparator :                         (t, comparator_witness)                         Core_kernel.Comparator.comparator                     end                   module Tree :                     sig                       type t =                           (node, comparator_witness)                           Core_kernel.Core_set.Tree.t                       val t_of_sexp : Sexplib.Sexp.t -> t                       val sexp_of_t : t -> Sexplib.Sexp.t                       val compare : t -> t -> int                       val length : t -> int                       val is_empty : t -> bool                       val iter : t -> f:(node -> unit) -> unit                       val fold :                         t ->                         init:'accum -> f:('accum -> node -> 'accum) -> 'accum                       val exists : t -> f:(node -> bool) -> bool                       val for_all : t -> f:(node -> bool) -> bool                       val count : t -> f:(node -> bool) -> int                       val sum :                         (module Core_kernel.Commutative_group.S with type t = 'sum) ->                         t -> f:(node -> 'sum) -> 'sum                       val find : t -> f:(node -> bool) -> node option                       val find_map : t -> f:(node -> 'a option) -> 'a option                       val to_list : t -> node list                       val to_array : t -> node array                       val invariants : t -> bool                       val mem : t -> node -> bool                       val add : t -> node -> t                       val remove : t -> node -> t                       val union : t -> t -> t                       val inter : t -> t -> t                       val diff : t -> t -> t                       val symmetric_diff :                         t ->                         t ->                         (node, node) Core_kernel.Either.t                         Core_kernel.Sequence.t                       val compare_direct : t -> t -> int                       val equal : t -> t -> bool                       val subset : t -> t -> bool                       val fold_until :                         t ->                         init:'->                         f:('-> node -> [ `Continue of '| `Stop of 'b ]) ->                         'b                       val fold_right :                         t -> init:'-> f:(node -> '-> 'b) -> 'b                       val iter2 :                         t ->                         t ->                         f:([ `Both of node * node                            | `Left of node                            | `Right of node ] -> unit) ->                         unit                       val filter : t -> f:(node -> bool) -> t                       val partition_tf : t -> f:(node -> bool) -> t * t                       val elements : t -> node list                       val min_elt : t -> node option                       val min_elt_exn : t -> node                       val max_elt : t -> node option                       val max_elt_exn : t -> node                       val choose : t -> node option                       val choose_exn : t -> node                       val split : t -> node -> t * node option * t                       val group_by :                         t -> equiv:(node -> node -> bool) -> t list                       val find_exn : t -> f:(node -> bool) -> node                       val find_index : t -> int -> node option                       val remove_index : t -> int -> t                       val to_tree : t -> t                       val to_sequence :                         ?order:[ `Decreasing | `Increasing ] ->                         ?greater_or_equal_to:node ->                         ?less_or_equal_to:node ->                         t -> node Core_kernel.Sequence.t                       val merge_to_sequence :                         ?order:[ `Decreasing | `Increasing ] ->                         ?greater_or_equal_to:node ->                         ?less_or_equal_to:node ->                         t ->                         t ->                         node                         Core_kernel.Core_set_intf.Merge_to_sequence_element.t                         Core_kernel.Sequence.t                       val to_map :                         t ->                         f:(node -> 'data) ->                         (node, 'data, comparator_witness)                         Core_kernel.Core_set_intf.Map.t                       val obs :                         node Core_kernel.Quickcheck.obs ->                         t Core_kernel.Quickcheck.obs                       val shrinker :                         node Core_kernel.Quickcheck.shr ->                         t Core_kernel.Quickcheck.shr                       val empty : t                       val singleton : node -> t                       val union_list : t list -> t                       val of_list : node list -> t                       val of_array : node array -> t                       val of_sorted_array :                         node array -> t Core_kernel.Or_error.t                       val of_sorted_array_unchecked : node array -> t                       val stable_dedup_list : node list -> node list                       val map :                         ('a, 'b) Core_kernel.Core_set.Tree.t ->                         f:('-> node) -> t                       val filter_map :                         ('a, 'b) Core_kernel.Core_set.Tree.t ->                         f:('-> node option) -> t                       val of_tree : t -> t                       val of_map_keys :                         (node, 'a, comparator_witness)                         Core_kernel.Core_set_intf.Map.t -> t                       val gen :                         node Core_kernel.Quickcheck.Generator.t ->                         t Core_kernel.Quickcheck.Generator.t                     end                   type t = (node, comparator_witness) Core_kernel.Core_set.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val length : t -> int                   val is_empty : t -> bool                   val iter : t -> f:(node -> unit) -> unit                   val fold :                     t ->                     init:'accum -> f:('accum -> node -> 'accum) -> 'accum                   val exists : t -> f:(node -> bool) -> bool                   val for_all : t -> f:(node -> bool) -> bool                   val count : t -> f:(node -> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     t -> f:(node -> 'sum) -> 'sum                   val find : t -> f:(node -> bool) -> node option                   val find_map : t -> f:(node -> 'a option) -> 'a option                   val to_list : t -> node list                   val to_array : t -> node array                   val invariants : t -> bool                   val mem : t -> node -> bool                   val add : t -> node -> t                   val remove : t -> node -> t                   val union : t -> t -> t                   val inter : t -> t -> t                   val diff : t -> t -> t                   val symmetric_diff :                     t ->                     t ->                     (node, node) Core_kernel.Either.t Core_kernel.Sequence.t                   val compare_direct : t -> t -> int                   val equal : t -> t -> bool                   val subset : t -> t -> bool                   val fold_until :                     t ->                     init:'->                     f:('-> node -> [ `Continue of '| `Stop of 'b ]) -> 'b                   val fold_right : t -> init:'-> f:(node -> '-> 'b) -> 'b                   val iter2 :                     t ->                     t ->                     f:([ `Both of node * node                        | `Left of node                        | `Right of node ] -> unit) ->                     unit                   val filter : t -> f:(node -> bool) -> t                   val partition_tf : t -> f:(node -> bool) -> t * t                   val elements : t -> node list                   val min_elt : t -> node option                   val min_elt_exn : t -> node                   val max_elt : t -> node option                   val max_elt_exn : t -> node                   val choose : t -> node option                   val choose_exn : t -> node                   val split : t -> node -> t * node option * t                   val group_by : t -> equiv:(node -> node -> bool) -> t list                   val find_exn : t -> f:(node -> bool) -> node                   val find_index : t -> int -> node option                   val remove_index : t -> int -> t                   val to_tree : t -> Tree.t                   val to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:node ->                     ?less_or_equal_to:node ->                     t -> node Core_kernel.Sequence.t                   val merge_to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:node ->                     ?less_or_equal_to:node ->                     t ->                     t ->                     node                     Core_kernel.Core_set_intf.Merge_to_sequence_element.t                     Core_kernel.Sequence.t                   val to_map :                     t ->                     f:(node -> 'data) ->                     (node, 'data, comparator_witness)                     Core_kernel.Core_set_intf.Map.t                   val obs :                     node Core_kernel.Quickcheck.obs ->                     t Core_kernel.Quickcheck.obs                   val shrinker :                     node Core_kernel.Quickcheck.shr ->                     t Core_kernel.Quickcheck.shr                   val empty : t                   val singleton : node -> t                   val union_list : t list -> t                   val of_list : node list -> t                   val of_array : node array -> t                   val of_sorted_array :                     node array -> t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : node array -> t                   val stable_dedup_list : node list -> node list                   val map :                     ('a, 'b) Core_kernel.Core_set.t -> f:('-> node) -> t                   val filter_map :                     ('a, 'b) Core_kernel.Core_set.t ->                     f:('-> node option) -> t                   val of_tree : Tree.t -> t                   val of_map_keys :                     (node, 'a, comparator_witness)                     Core_kernel.Core_set_intf.Map.t -> t                   val gen :                     node Core_kernel.Quickcheck.Generator.t ->                     t Core_kernel.Quickcheck.Generator.t                 end               val hash : t -> int               val compare : t -> t -> int               val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t               module Table :                 sig                   type key = t                   type ('a, 'b) hashtbl =                       ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t                   type 'b t = (key, 'b) hashtbl                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                   type ('a, 'b) t_ = 'b t                   type 'a key_ = key                   val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t                   val invariant :                     'Core_kernel.Invariant_intf.inv ->                     'a t Core_kernel.Invariant_intf.inv                   val create :                     (key, 'b, unit -> 'b t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist :                     (key, 'b,                      (key * 'b) list ->                      [ `Duplicate_key of key | `Ok of 'b t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_report_all_dups :                     (key, 'b,                      (key * 'b) list ->                      [ `Duplicate_keys of key list | `Ok of 'b t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_or_error :                     (key, 'b, (key * 'b) list -> 'b t Core_kernel.Or_error.t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_exn :                     (key, 'b, (key * 'b) list -> 'b t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_multi :                     (key, 'b list, (key * 'b) list -> 'b list t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_mapped :                     (key, 'b,                      get_key:('-> key) ->                      get_data:('-> 'b) ->                      'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_with_key :                     (key, 'r,                      get_key:('-> key) ->                      'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_with_key_or_error :                     (key, 'r,                      get_key:('-> key) ->                      'r list -> 'r t Core_kernel.Or_error.t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_with_key_exn :                     (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val group :                     (key, 'b,                      get_key:('-> key) ->                      get_data:('-> 'b) ->                      combine:('-> '-> 'b) -> 'r list -> 'b t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                   val clear : 'a t -> unit                   val copy : 'b t -> 'b t                   val fold :                     'b t ->                     init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                   val iter_vals : 'b t -> f:('-> unit) -> unit                   val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(key -> unit) -> unit                   val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                   val existsi :                     'b t -> f:(key:key -> data:'-> bool) -> bool                   val exists : 'b t -> f:('-> bool) -> bool                   val for_alli :                     'b t -> f:(key:key -> data:'-> bool) -> bool                   val for_all : 'b t -> f:('-> bool) -> bool                   val counti : 'b t -> f:(key:key -> data:'-> bool) -> int                   val count : 'b t -> f:('-> bool) -> int                   val length : 'a t -> int                   val is_empty : 'a t -> bool                   val mem : 'a t -> key -> bool                   val remove : 'a t -> key -> unit                   val replace : 'b t -> key:key -> data:'-> unit                   val set : 'b t -> key:key -> data:'-> unit                   val add :                     'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                   val add_or_error :                     'b t -> key:key -> data:'-> unit Core_kernel.Or_error.t                   val add_exn : 'b t -> key:key -> data:'-> unit                   val change :                     'b t -> key -> f:('b option -> 'b option) -> unit                   val update : 'b t -> key -> f:('b option -> 'b) -> unit                   val add_multi : 'b list t -> key:key -> data:'-> unit                   val remove_multi : 'a list t -> key -> unit                   val map :                     ('c, 'b t -> f:('-> 'c) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val mapi :                     ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val filter_map :                     ('c, 'b t -> f:('-> 'c option) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val filter_mapi :                     ('c, 'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val filter : 'b t -> f:('-> bool) -> 'b t                   val filteri :                     'b t -> f:(key:key -> data:'-> bool) -> 'b t                   val partition_map :                     ('c,                      ('d,                       'b t ->                       f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                      Core_kernel.Core_hashtbl_intf.no_map_options)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val partition_mapi :                     ('c,                      ('d,                       'b t ->                       f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                       'c t * 'd t)                      Core_kernel.Core_hashtbl_intf.no_map_options)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                   val partitioni_tf :                     'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                   val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b                   val find : 'b t -> key -> 'b option                   val find_exn : 'b t -> key -> 'b                   val find_and_call :                     'b t ->                     key ->                     if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                   val find_and_remove : 'b t -> key -> 'b option                   val merge :                     ('c,                      'a t ->                      'b t ->                      f:(key:key ->                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                         'c option) ->                      'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   type 'a merge_into_action = Remove | Set_to of 'a                   val merge_into :                     src:'a t ->                     dst:'b t ->                     f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                     unit                   val keys : 'a t -> key list                   val data : 'b t -> 'b list                   val filter_inplace : 'b t -> f:('-> bool) -> unit                   val filteri_inplace :                     'b t -> f:(key:key -> data:'-> bool) -> unit                   val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                   val map_inplace : 'b t -> f:('-> 'b) -> unit                   val mapi_inplace :                     'b t -> f:(key:key -> data:'-> 'b) -> unit                   val filter_map_inplace :                     'b t -> f:('-> 'b option) -> unit                   val filter_mapi_inplace :                     'b t -> f:(key:key -> data:'-> 'b option) -> unit                   val replace_all : 'b t -> f:('-> 'b) -> unit                   val replace_alli :                     'b t -> f:(key:key -> data:'-> 'b) -> unit                   val filter_replace_all :                     'b t -> f:('-> 'b option) -> unit                   val filter_replace_alli :                     'b t -> f:(key:key -> data:'-> 'b option) -> unit                   val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                   val similar :                     'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                   val to_alist : 'b t -> (key * 'b) list                   val validate :                     name:(key -> string) ->                     'Core_kernel.Validate.check ->                     'b t Core_kernel.Validate.check                   val incr :                     ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   val decr :                     ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                 end               module Hash_set :                 sig                   type elt = t                   type 'a hash_set = 'Core_kernel.Hash_set.t                   type t = elt hash_set                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   type 'a t_ = t                   type 'a elt_ = elt                   val create :                     ('a, unit -> t)                     Core_kernel.Hash_set_intf.create_options_without_hashable                   val of_list :                     ('a, elt list -> t)                     Core_kernel.Hash_set_intf.create_options_without_hashable                 end               module Hash_queue :                 sig                   module Key :                     sig                       type t = node                       val t_of_sexp : Sexplib.Sexp.t -> t                       val sexp_of_t : t -> Sexplib.Sexp.t                       val compare : t -> t -> int                       val hash : t -> int                     end                   type 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val length : 'a t -> int                   val is_empty : 'a t -> bool                   val iter : 'a t -> f:('-> unit) -> unit                   val fold :                     'a t ->                     init:'accum -> f:('accum -> '-> 'accum) -> 'accum                   val exists : 'a t -> f:('-> bool) -> bool                   val for_all : 'a t -> f:('-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     'a t -> f:('-> 'sum) -> 'sum                   val find : 'a t -> f:('-> bool) -> 'a option                   val find_map : 'a t -> f:('-> 'b option) -> 'b option                   val to_list : 'a t -> 'a list                   val to_array : 'a t -> 'a array                   val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                   val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                   val invariant : 'a t -> unit                   val create :                     ?growth_allowed:bool -> ?size:int -> unit -> 'a t                   val clear : 'a t -> unit                   val mem : 'a t -> node -> bool                   val lookup : 'a t -> node -> 'a option                   val lookup_exn : 'a t -> node -> 'a                   val enqueue :                     'a t -> node -> '-> [ `Key_already_present | `Ok ]                   val enqueue_exn : 'a t -> node -> '-> unit                   val first : 'a t -> 'a option                   val first_with_key : 'a t -> (node * 'a) option                   val keys : 'a t -> node list                   val dequeue : 'a t -> 'a option                   val dequeue_exn : 'a t -> 'a                   val dequeue_with_key : 'a t -> (node * 'a) option                   val dequeue_with_key_exn : 'a t -> node * 'a                   val dequeue_all : 'a t -> f:('-> unit) -> unit                   val remove : 'a t -> node -> [ `No_such_key | `Ok ]                   val remove_exn : 'a t -> node -> unit                   val replace : 'a t -> node -> '-> [ `No_such_key | `Ok ]                   val replace_exn : 'a t -> node -> '-> unit                   val iteri : 'a t -> f:(key:node -> data:'-> unit) -> unit                   val foldi :                     'a t ->                     init:'-> f:('-> key:node -> data:'-> 'b) -> 'b                 end             end           module Edge :             sig               type t = edge               type node = Node.t               type graph = Node.graph               type label               val create : node -> node -> label -> t               val label : t -> label               val src : t -> node               val dst : t -> node               val mem : t -> graph -> bool               val insert : t -> graph -> graph               val update : t -> label -> graph -> graph               val remove : t -> graph -> graph               val ( >= ) : t -> t -> bool               val ( <= ) : t -> t -> bool               val ( = ) : t -> t -> bool               val ( > ) : t -> t -> bool               val ( < ) : t -> t -> bool               val ( <> ) : t -> t -> bool               val equal : t -> t -> bool               val min : t -> t -> t               val max : t -> t -> t               val ascending : t -> t -> int               val descending : t -> t -> int               val between : t -> low:t -> high:t -> bool               val clamp_exn : t -> min:t -> max:t -> t               val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t               module Replace_polymorphic_compare :                 sig                   val ( >= ) : t -> t -> bool                   val ( <= ) : t -> t -> bool                   val ( = ) : t -> t -> bool                   val ( > ) : t -> t -> bool                   val ( < ) : t -> t -> bool                   val ( <> ) : t -> t -> bool                   val equal : t -> t -> bool                   val compare : t -> t -> int                   val min : t -> t -> t                   val max : t -> t -> t                 end               type comparator_witness               val comparator :                 (t, comparator_witness) Core_kernel.Comparator.comparator               val validate_lbound :                 min:t Core_kernel.Maybe_bound.t ->                 t Core_kernel.Validate.check               val validate_ubound :                 max:t Core_kernel.Maybe_bound.t ->                 t Core_kernel.Validate.check               val validate_bound :                 min:t Core_kernel.Maybe_bound.t ->                 max:t Core_kernel.Maybe_bound.t ->                 t Core_kernel.Validate.check               module Map :                 sig                   module Key :                     sig                       type t = edge                       type comparator_witness = comparator_witness                       val comparator :                         (t, comparator_witness)                         Core_kernel.Comparator.comparator                     end                   module Tree :                     sig                       type 'a t =                           (edge, 'a, comparator_witness)                           Core_kernel.Core_map.Tree.t                       val t_of_sexp :                         (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                       val sexp_of_t :                         ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                       val empty : 'a t                       val singleton : edge -> '-> 'a t                       val of_alist :                         (edge * 'a) list ->                         [ `Duplicate_key of edge | `Ok of 'a t ]                       val of_alist_or_error :                         (edge * 'a) list -> 'a t Core_kernel.Or_error.t                       val of_alist_exn : (edge * 'a) list -> 'a t                       val of_alist_multi : (edge * 'a) list -> 'a list t                       val of_alist_fold :                         (edge * 'a) list ->                         init:'-> f:('-> '-> 'b) -> 'b t                       val of_alist_reduce :                         (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                       val of_sorted_array :                         (edge * 'a) array -> 'a t Core_kernel.Or_error.t                       val of_sorted_array_unchecked :                         (edge * 'a) array -> 'a t                       val of_tree : 'a t -> 'a t                       val gen :                         edge Core_kernel.Quickcheck.Generator.t ->                         'Core_kernel.Quickcheck.Generator.t ->                         'a t Core_kernel.Quickcheck.Generator.t                       val invariants : 'a t -> bool                       val is_empty : 'a t -> bool                       val length : 'a t -> int                       val add : 'a t -> key:edge -> data:'-> 'a t                       val add_multi :                         'a list t -> key:edge -> data:'-> 'a list t                       val remove_multi : 'a list t -> edge -> 'a list t                       val change :                         'a t -> edge -> f:('a option -> 'a option) -> 'a t                       val update :                         'a t -> edge -> f:('a option -> 'a) -> 'a t                       val find : 'a t -> edge -> 'a option                       val find_exn : 'a t -> edge -> 'a                       val remove : 'a t -> edge -> 'a t                       val mem : 'a t -> edge -> bool                       val iter :                         'a t -> f:(key:edge -> data:'-> unit) -> unit                       val iteri :                         'a t -> f:(key:edge -> data:'-> unit) -> unit                       val iter_keys : 'a t -> f:(edge -> unit) -> unit                       val iter2 :                         'a t ->                         'b t ->                         f:(key:edge ->                            data:[ `Both of 'a * 'b                                 | `Left of 'a                                 | `Right of 'b ] ->                            unit) ->                         unit                       val map : 'a t -> f:('-> 'b) -> 'b t                       val mapi :                         'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                       val fold :                         'a t ->                         init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b                       val fold_right :                         'a t ->                         init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b                       val fold2 :                         'a t ->                         'b t ->                         init:'->                         f:(key:edge ->                            data:[ `Both of 'a * 'b                                 | `Left of 'a                                 | `Right of 'b ] ->                            '-> 'c) ->                         'c                       val filter :                         'a t -> f:(key:edge -> data:'-> bool) -> 'a t                       val filteri :                         'a t -> f:(key:edge -> data:'-> bool) -> 'a t                       val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                       val filter_map : 'a t -> f:('-> 'b option) -> 'b t                       val filter_mapi :                         'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t                       val partition_mapi :                         'a t ->                         f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                         'b t * 'c t                       val partition_map :                         'a t ->                         f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                       val partitioni_tf :                         'a t ->                         f:(key:edge -> data:'-> bool) -> 'a t * 'a t                       val partition_tf :                         'a t -> f:('-> bool) -> 'a t * 'a t                       val compare_direct :                         ('-> '-> int) -> 'a t -> 'a t -> int                       val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                       val keys : 'a t -> edge list                       val data : 'a t -> 'a list                       val to_alist :                         ?key_order:[ `Decreasing | `Increasing ] ->                         'a t -> (edge * 'a) list                       val validate :                         name:(edge -> string) ->                         'Core_kernel.Validate.check ->                         'a t Core_kernel.Validate.check                       val merge :                         'a t ->                         'b t ->                         f:(key:edge ->                            [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                            'c option) ->                         'c t                       val symmetric_diff :                         'a t ->                         'a t ->                         data_equal:('-> '-> bool) ->                         (edge, 'a)                         Core_kernel.Core_map_intf.Symmetric_diff_element.t                         Core_kernel.Sequence.t                       val min_elt : 'a t -> (edge * 'a) option                       val min_elt_exn : 'a t -> edge * 'a                       val max_elt : 'a t -> (edge * 'a) option                       val max_elt_exn : 'a t -> edge * 'a                       val for_all : 'a t -> f:('-> bool) -> bool                       val for_alli :                         'a t -> f:(key:edge -> data:'-> bool) -> bool                       val exists : 'a t -> f:('-> bool) -> bool                       val existsi :                         'a t -> f:(key:edge -> data:'-> bool) -> bool                       val count : 'a t -> f:('-> bool) -> int                       val counti :                         'a t -> f:(key:edge -> data:'-> bool) -> int                       val split :                         'a t -> edge -> 'a t * (edge * 'a) option * 'a t                       val fold_range_inclusive :                         'a t ->                         min:edge ->                         max:edge ->                         init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b                       val range_to_alist :                         'a t -> min:edge -> max:edge -> (edge * 'a) list                       val closest_key :                         'a t ->                         [ `Greater_or_equal_to                         | `Greater_than                         | `Less_or_equal_to                         | `Less_than ] -> edge -> (edge * 'a) option                       val nth : 'a t -> int -> (edge * 'a) option                       val rank : 'a t -> edge -> int option                       val to_tree : 'a t -> 'a t                       val to_sequence :                         ?order:[ `Decreasing_key | `Increasing_key ] ->                         ?keys_greater_or_equal_to:edge ->                         ?keys_less_or_equal_to:edge ->                         'a t -> (edge * 'a) Core_kernel.Sequence.t                       val obs :                         edge Core_kernel.Quickcheck.Observer.t ->                         'Core_kernel.Quickcheck.Observer.t ->                         'v t Core_kernel.Quickcheck.Observer.t                       val shrinker :                         edge Core_kernel.Quickcheck.Shrinker.t ->                         'Core_kernel.Quickcheck.Shrinker.t ->                         'v t Core_kernel.Quickcheck.Shrinker.t                     end                   type 'a t =                       (edge, 'a, comparator_witness) Core_kernel.Core_map.t                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val compare : ('-> '-> int) -> 'a t -> 'a t -> int                   val empty : 'a t                   val singleton : edge -> '-> 'a t                   val of_alist :                     (edge * 'a) list ->                     [ `Duplicate_key of edge | `Ok of 'a t ]                   val of_alist_or_error :                     (edge * 'a) list -> 'a t Core_kernel.Or_error.t                   val of_alist_exn : (edge * 'a) list -> 'a t                   val of_alist_multi : (edge * 'a) list -> 'a list t                   val of_alist_fold :                     (edge * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t                   val of_alist_reduce :                     (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                   val of_sorted_array :                     (edge * 'a) array -> 'a t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : (edge * 'a) array -> 'a t                   val of_tree : 'Tree.t -> 'a t                   val gen :                     edge Core_kernel.Quickcheck.Generator.t ->                     'Core_kernel.Quickcheck.Generator.t ->                     'a t Core_kernel.Quickcheck.Generator.t                   val invariants : 'a t -> bool                   val is_empty : 'a t -> bool                   val length : 'a t -> int                   val add : 'a t -> key:edge -> data:'-> 'a t                   val add_multi :                     'a list t -> key:edge -> data:'-> 'a list t                   val remove_multi : 'a list t -> edge -> 'a list t                   val change :                     'a t -> edge -> f:('a option -> 'a option) -> 'a t                   val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t                   val find : 'a t -> edge -> 'a option                   val find_exn : 'a t -> edge -> 'a                   val remove : 'a t -> edge -> 'a t                   val mem : 'a t -> edge -> bool                   val iter : 'a t -> f:(key:edge -> data:'-> unit) -> unit                   val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(edge -> unit) -> unit                   val iter2 :                     'a t ->                     'b t ->                     f:(key:edge ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        unit) ->                     unit                   val map : 'a t -> f:('-> 'b) -> 'b t                   val mapi : 'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                   val fold :                     'a t ->                     init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b                   val fold_right :                     'a t ->                     init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b                   val fold2 :                     'a t ->                     'b t ->                     init:'->                     f:(key:edge ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        '-> 'c) ->                     'c                   val filter :                     'a t -> f:(key:edge -> data:'-> bool) -> 'a t                   val filteri :                     'a t -> f:(key:edge -> data:'-> bool) -> 'a t                   val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                   val filter_map : 'a t -> f:('-> 'b option) -> 'b t                   val filter_mapi :                     'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t                   val partition_mapi :                     'a t ->                     f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                     'b t * 'c t                   val partition_map :                     'a t ->                     f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                   val partitioni_tf :                     'a t -> f:(key:edge -> data:'-> bool) -> 'a t * 'a t                   val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                   val compare_direct :                     ('-> '-> int) -> 'a t -> 'a t -> int                   val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                   val keys : 'a t -> edge list                   val data : 'a t -> 'a list                   val to_alist :                     ?key_order:[ `Decreasing | `Increasing ] ->                     'a t -> (edge * 'a) list                   val validate :                     name:(edge -> string) ->                     'Core_kernel.Validate.check ->                     'a t Core_kernel.Validate.check                   val merge :                     'a t ->                     'b t ->                     f:(key:edge ->                        [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        'c option) ->                     'c t                   val symmetric_diff :                     'a t ->                     'a t ->                     data_equal:('-> '-> bool) ->                     (edge, 'a)                     Core_kernel.Core_map_intf.Symmetric_diff_element.t                     Core_kernel.Sequence.t                   val min_elt : 'a t -> (edge * 'a) option                   val min_elt_exn : 'a t -> edge * 'a                   val max_elt : 'a t -> (edge * 'a) option                   val max_elt_exn : 'a t -> edge * 'a                   val for_all : 'a t -> f:('-> bool) -> bool                   val for_alli :                     'a t -> f:(key:edge -> data:'-> bool) -> bool                   val exists : 'a t -> f:('-> bool) -> bool                   val existsi :                     'a t -> f:(key:edge -> data:'-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val counti : 'a t -> f:(key:edge -> data:'-> bool) -> int                   val split :                     'a t -> edge -> 'a t * (edge * 'a) option * 'a t                   val fold_range_inclusive :                     'a t ->                     min:edge ->                     max:edge ->                     init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b                   val range_to_alist :                     'a t -> min:edge -> max:edge -> (edge * 'a) list                   val closest_key :                     'a t ->                     [ `Greater_or_equal_to                     | `Greater_than                     | `Less_or_equal_to                     | `Less_than ] -> edge -> (edge * 'a) option                   val nth : 'a t -> int -> (edge * 'a) option                   val rank : 'a t -> edge -> int option                   val to_tree : 'a t -> 'Tree.t                   val to_sequence :                     ?order:[ `Decreasing_key | `Increasing_key ] ->                     ?keys_greater_or_equal_to:edge ->                     ?keys_less_or_equal_to:edge ->                     'a t -> (edge * 'a) Core_kernel.Sequence.t                   val obs :                     edge Core_kernel.Quickcheck.Observer.t ->                     'Core_kernel.Quickcheck.Observer.t ->                     'v t Core_kernel.Quickcheck.Observer.t                   val shrinker :                     edge Core_kernel.Quickcheck.Shrinker.t ->                     'Core_kernel.Quickcheck.Shrinker.t ->                     'v t Core_kernel.Quickcheck.Shrinker.t                 end               module Set :                 sig                   module Elt :                     sig                       type t = edge                       val t_of_sexp : Sexplib.Sexp.t -> t                       val sexp_of_t : t -> Sexplib.Sexp.t                       type comparator_witness = Map.Key.comparator_witness                       val comparator :                         (t, comparator_witness)                         Core_kernel.Comparator.comparator                     end                   module Tree :                     sig                       type t =                           (edge, comparator_witness)                           Core_kernel.Core_set.Tree.t                       val t_of_sexp : Sexplib.Sexp.t -> t                       val sexp_of_t : t -> Sexplib.Sexp.t                       val compare : t -> t -> int                       val length : t -> int                       val is_empty : t -> bool                       val iter : t -> f:(edge -> unit) -> unit                       val fold :                         t ->                         init:'accum -> f:('accum -> edge -> 'accum) -> 'accum                       val exists : t -> f:(edge -> bool) -> bool                       val for_all : t -> f:(edge -> bool) -> bool                       val count : t -> f:(edge -> bool) -> int                       val sum :                         (module Core_kernel.Commutative_group.S with type t = 'sum) ->                         t -> f:(edge -> 'sum) -> 'sum                       val find : t -> f:(edge -> bool) -> edge option                       val find_map : t -> f:(edge -> 'a option) -> 'a option                       val to_list : t -> edge list                       val to_array : t -> edge array                       val invariants : t -> bool                       val mem : t -> edge -> bool                       val add : t -> edge -> t                       val remove : t -> edge -> t                       val union : t -> t -> t                       val inter : t -> t -> t                       val diff : t -> t -> t                       val symmetric_diff :                         t ->                         t ->                         (edge, edge) Core_kernel.Either.t                         Core_kernel.Sequence.t                       val compare_direct : t -> t -> int                       val equal : t -> t -> bool                       val subset : t -> t -> bool                       val fold_until :                         t ->                         init:'->                         f:('-> edge -> [ `Continue of '| `Stop of 'b ]) ->                         'b                       val fold_right :                         t -> init:'-> f:(edge -> '-> 'b) -> 'b                       val iter2 :                         t ->                         t ->                         f:([ `Both of edge * edge                            | `Left of edge                            | `Right of edge ] -> unit) ->                         unit                       val filter : t -> f:(edge -> bool) -> t                       val partition_tf : t -> f:(edge -> bool) -> t * t                       val elements : t -> edge list                       val min_elt : t -> edge option                       val min_elt_exn : t -> edge                       val max_elt : t -> edge option                       val max_elt_exn : t -> edge                       val choose : t -> edge option                       val choose_exn : t -> edge                       val split : t -> edge -> t * edge option * t                       val group_by :                         t -> equiv:(edge -> edge -> bool) -> t list                       val find_exn : t -> f:(edge -> bool) -> edge                       val find_index : t -> int -> edge option                       val remove_index : t -> int -> t                       val to_tree : t -> t                       val to_sequence :                         ?order:[ `Decreasing | `Increasing ] ->                         ?greater_or_equal_to:edge ->                         ?less_or_equal_to:edge ->                         t -> edge Core_kernel.Sequence.t                       val merge_to_sequence :                         ?order:[ `Decreasing | `Increasing ] ->                         ?greater_or_equal_to:edge ->                         ?less_or_equal_to:edge ->                         t ->                         t ->                         edge                         Core_kernel.Core_set_intf.Merge_to_sequence_element.t                         Core_kernel.Sequence.t                       val to_map :                         t ->                         f:(edge -> 'data) ->                         (edge, 'data, comparator_witness)                         Core_kernel.Core_set_intf.Map.t                       val obs :                         edge Core_kernel.Quickcheck.obs ->                         t Core_kernel.Quickcheck.obs                       val shrinker :                         edge Core_kernel.Quickcheck.shr ->                         t Core_kernel.Quickcheck.shr                       val empty : t                       val singleton : edge -> t                       val union_list : t list -> t                       val of_list : edge list -> t                       val of_array : edge array -> t                       val of_sorted_array :                         edge array -> t Core_kernel.Or_error.t                       val of_sorted_array_unchecked : edge array -> t                       val stable_dedup_list : edge list -> edge list                       val map :                         ('a, 'b) Core_kernel.Core_set.Tree.t ->                         f:('-> edge) -> t                       val filter_map :                         ('a, 'b) Core_kernel.Core_set.Tree.t ->                         f:('-> edge option) -> t                       val of_tree : t -> t                       val of_map_keys :                         (edge, 'a, comparator_witness)                         Core_kernel.Core_set_intf.Map.t -> t                       val gen :                         edge Core_kernel.Quickcheck.Generator.t ->                         t Core_kernel.Quickcheck.Generator.t                     end                   type t = (edge, comparator_witness) Core_kernel.Core_set.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val length : t -> int                   val is_empty : t -> bool                   val iter : t -> f:(edge -> unit) -> unit                   val fold :                     t ->                     init:'accum -> f:('accum -> edge -> 'accum) -> 'accum                   val exists : t -> f:(edge -> bool) -> bool                   val for_all : t -> f:(edge -> bool) -> bool                   val count : t -> f:(edge -> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     t -> f:(edge -> 'sum) -> 'sum                   val find : t -> f:(edge -> bool) -> edge option                   val find_map : t -> f:(edge -> 'a option) -> 'a option                   val to_list : t -> edge list                   val to_array : t -> edge array                   val invariants : t -> bool                   val mem : t -> edge -> bool                   val add : t -> edge -> t                   val remove : t -> edge -> t                   val union : t -> t -> t                   val inter : t -> t -> t                   val diff : t -> t -> t                   val symmetric_diff :                     t ->                     t ->                     (edge, edge) Core_kernel.Either.t Core_kernel.Sequence.t                   val compare_direct : t -> t -> int                   val equal : t -> t -> bool                   val subset : t -> t -> bool                   val fold_until :                     t ->                     init:'->                     f:('-> edge -> [ `Continue of '| `Stop of 'b ]) -> 'b                   val fold_right : t -> init:'-> f:(edge -> '-> 'b) -> 'b                   val iter2 :                     t ->                     t ->                     f:([ `Both of edge * edge                        | `Left of edge                        | `Right of edge ] -> unit) ->                     unit                   val filter : t -> f:(edge -> bool) -> t                   val partition_tf : t -> f:(edge -> bool) -> t * t                   val elements : t -> edge list                   val min_elt : t -> edge option                   val min_elt_exn : t -> edge                   val max_elt : t -> edge option                   val max_elt_exn : t -> edge                   val choose : t -> edge option                   val choose_exn : t -> edge                   val split : t -> edge -> t * edge option * t                   val group_by : t -> equiv:(edge -> edge -> bool) -> t list                   val find_exn : t -> f:(edge -> bool) -> edge                   val find_index : t -> int -> edge option                   val remove_index : t -> int -> t                   val to_tree : t -> Tree.t                   val to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:edge ->                     ?less_or_equal_to:edge ->                     t -> edge Core_kernel.Sequence.t                   val merge_to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:edge ->                     ?less_or_equal_to:edge ->                     t ->                     t ->                     edge                     Core_kernel.Core_set_intf.Merge_to_sequence_element.t                     Core_kernel.Sequence.t                   val to_map :                     t ->                     f:(edge -> 'data) ->                     (edge, 'data, comparator_witness)                     Core_kernel.Core_set_intf.Map.t                   val obs :                     edge Core_kernel.Quickcheck.obs ->                     t Core_kernel.Quickcheck.obs                   val shrinker :                     edge Core_kernel.Quickcheck.shr ->                     t Core_kernel.Quickcheck.shr                   val empty : t                   val singleton : edge -> t                   val union_list : t list -> t                   val of_list : edge list -> t                   val of_array : edge array -> t                   val of_sorted_array :                     edge array -> t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : edge array -> t                   val stable_dedup_list : edge list -> edge list                   val map :                     ('a, 'b) Core_kernel.Core_set.t -> f:('-> edge) -> t                   val filter_map :                     ('a, 'b) Core_kernel.Core_set.t ->                     f:('-> edge option) -> t                   val of_tree : Tree.t -> t                   val of_map_keys :                     (edge, 'a, comparator_witness)                     Core_kernel.Core_set_intf.Map.t -> t                   val gen :                     edge Core_kernel.Quickcheck.Generator.t ->                     t Core_kernel.Quickcheck.Generator.t                 end               val hash : t -> int               val compare : t -> t -> int               val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t               module Table :                 sig                   type key = t                   type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl                   type 'b t = (key, 'b) hashtbl                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                   type ('a, 'b) t_ = 'b t                   type 'a key_ = key                   val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t                   val invariant :                     'Core_kernel.Invariant_intf.inv ->                     'a t Core_kernel.Invariant_intf.inv                   val create :                     (key, 'b, unit -> 'b t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist :                     (key, 'b,                      (key * 'b) list ->                      [ `Duplicate_key of key | `Ok of 'b t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_report_all_dups :                     (key, 'b,                      (key * 'b) list ->                      [ `Duplicate_keys of key list | `Ok of 'b t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_or_error :                     (key, 'b, (key * 'b) list -> 'b t Core_kernel.Or_error.t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_exn :                     (key, 'b, (key * 'b) list -> 'b t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val of_alist_multi :                     (key, 'b list, (key * 'b) list -> 'b list t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_mapped :                     (key, 'b,                      get_key:('-> key) ->                      get_data:('-> 'b) ->                      'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_with_key :                     (key, 'r,                      get_key:('-> key) ->                      'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_with_key_or_error :                     (key, 'r,                      get_key:('-> key) ->                      'r list -> 'r t Core_kernel.Or_error.t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val create_with_key_exn :                     (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val group :                     (key, 'b,                      get_key:('-> key) ->                      get_data:('-> 'b) ->                      combine:('-> '-> 'b) -> 'r list -> 'b t)                     Core_kernel.Core_hashtbl_intf.create_options_without_hashable                   val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                   val clear : 'a t -> unit                   val copy : 'b t -> 'b t                   val fold :                     'b t ->                     init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                   val iter_vals : 'b t -> f:('-> unit) -> unit                   val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(key -> unit) -> unit                   val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                   val existsi :                     'b t -> f:(key:key -> data:'-> bool) -> bool                   val exists : 'b t -> f:('-> bool) -> bool                   val for_alli :                     'b t -> f:(key:key -> data:'-> bool) -> bool                   val for_all : 'b t -> f:('-> bool) -> bool                   val counti : 'b t -> f:(key:key -> data:'-> bool) -> int                   val count : 'b t -> f:('-> bool) -> int                   val length : 'a t -> int                   val is_empty : 'a t -> bool                   val mem : 'a t -> key -> bool                   val remove : 'a t -> key -> unit                   val replace : 'b t -> key:key -> data:'-> unit                   val set : 'b t -> key:key -> data:'-> unit                   val add :                     'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                   val add_or_error :                     'b t -> key:key -> data:'-> unit Core_kernel.Or_error.t                   val add_exn : 'b t -> key:key -> data:'-> unit                   val change :                     'b t -> key -> f:('b option -> 'b option) -> unit                   val update : 'b t -> key -> f:('b option -> 'b) -> unit                   val add_multi : 'b list t -> key:key -> data:'-> unit                   val remove_multi : 'a list t -> key -> unit                   val map :                     ('c, 'b t -> f:('-> 'c) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val mapi :                     ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val filter_map :                     ('c, 'b t -> f:('-> 'c option) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val filter_mapi :                     ('c, 'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val filter : 'b t -> f:('-> bool) -> 'b t                   val filteri :                     'b t -> f:(key:key -> data:'-> bool) -> 'b t                   val partition_map :                     ('c,                      ('d,                       'b t ->                       f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                      Core_kernel.Core_hashtbl_intf.no_map_options)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val partition_mapi :                     ('c,                      ('d,                       'b t ->                       f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                       'c t * 'd t)                      Core_kernel.Core_hashtbl_intf.no_map_options)                     Core_kernel.Core_hashtbl_intf.no_map_options                   val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                   val partitioni_tf :                     'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                   val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b                   val find : 'b t -> key -> 'b option                   val find_exn : 'b t -> key -> 'b                   val find_and_call :                     'b t ->                     key ->                     if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                   val find_and_remove : 'b t -> key -> 'b option                   val merge :                     ('c,                      'a t ->                      'b t ->                      f:(key:key ->                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                         'c option) ->                      'c t)                     Core_kernel.Core_hashtbl_intf.no_map_options                   type 'a merge_into_action = Remove | Set_to of 'a                   val merge_into :                     src:'a t ->                     dst:'b t ->                     f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                     unit                   val keys : 'a t -> key list                   val data : 'b t -> 'b list                   val filter_inplace : 'b t -> f:('-> bool) -> unit                   val filteri_inplace :                     'b t -> f:(key:key -> data:'-> bool) -> unit                   val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                   val map_inplace : 'b t -> f:('-> 'b) -> unit                   val mapi_inplace :                     'b t -> f:(key:key -> data:'-> 'b) -> unit                   val filter_map_inplace :                     'b t -> f:('-> 'b option) -> unit                   val filter_mapi_inplace :                     'b t -> f:(key:key -> data:'-> 'b option) -> unit                   val replace_all : 'b t -> f:('-> 'b) -> unit                   val replace_alli :                     'b t -> f:(key:key -> data:'-> 'b) -> unit                   val filter_replace_all :                     'b t -> f:('-> 'b option) -> unit                   val filter_replace_alli :                     'b t -> f:(key:key -> data:'-> 'b option) -> unit                   val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                   val similar :                     'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                   val to_alist : 'b t -> (key * 'b) list                   val validate :                     name:(key -> string) ->                     'Core_kernel.Validate.check ->                     'b t Core_kernel.Validate.check                   val incr :                     ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   val decr :                     ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                 end               module Hash_set :                 sig                   type elt = t                   type 'a hash_set = 'Node.Hash_set.hash_set                   type t = elt hash_set                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   type 'a t_ = t                   type 'a elt_ = elt                   val create :                     ('a, unit -> t)                     Core_kernel.Hash_set_intf.create_options_without_hashable                   val of_list :                     ('a, elt list -> t)                     Core_kernel.Hash_set_intf.create_options_without_hashable                 end               module Hash_queue :                 sig                   module Key :                     sig                       type t = edge                       val t_of_sexp : Sexplib.Sexp.t -> t                       val sexp_of_t : t -> Sexplib.Sexp.t                       val compare : t -> t -> int                       val hash : t -> int                     end                   type 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val length : 'a t -> int                   val is_empty : 'a t -> bool                   val iter : 'a t -> f:('-> unit) -> unit                   val fold :                     'a t ->                     init:'accum -> f:('accum -> '-> 'accum) -> 'accum                   val exists : 'a t -> f:('-> bool) -> bool                   val for_all : 'a t -> f:('-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     'a t -> f:('-> 'sum) -> 'sum                   val find : 'a t -> f:('-> bool) -> 'a option                   val find_map : 'a t -> f:('-> 'b option) -> 'b option                   val to_list : 'a t -> 'a list                   val to_array : 'a t -> 'a array                   val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                   val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                   val invariant : 'a t -> unit                   val create :                     ?growth_allowed:bool -> ?size:int -> unit -> 'a t                   val clear : 'a t -> unit                   val mem : 'a t -> edge -> bool                   val lookup : 'a t -> edge -> 'a option                   val lookup_exn : 'a t -> edge -> 'a                   val enqueue :                     'a t -> edge -> '-> [ `Key_already_present | `Ok ]                   val enqueue_exn : 'a t -> edge -> '-> unit                   val first : 'a t -> 'a option                   val first_with_key : 'a t -> (edge * 'a) option                   val keys : 'a t -> edge list                   val dequeue : 'a t -> 'a option                   val dequeue_exn : 'a t -> 'a                   val dequeue_with_key : 'a t -> (edge * 'a) option                   val dequeue_with_key_exn : 'a t -> edge * 'a                   val dequeue_all : 'a t -> f:('-> unit) -> unit                   val remove : 'a t -> edge -> [ `No_such_key | `Ok ]                   val remove_exn : 'a t -> edge -> unit                   val replace : 'a t -> edge -> '-> [ `No_such_key | `Ok ]                   val replace_exn : 'a t -> edge -> '-> unit                   val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit                   val foldi :                     'a t ->                     init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b                 end             end           val empty : Graphlib.Std.Graph.t           val nodes :             Graphlib.Std.Graph.t -> Graphlib.Std.Graph.node Regular.Std.seq           val edges :             Graphlib.Std.Graph.t -> Graphlib.Std.Graph.edge Regular.Std.seq           val is_directed : bool           val number_of_edges : Graphlib.Std.Graph.t -> int           val number_of_nodes : Graphlib.Std.Graph.t -> int           val ( >= ) : t -> t -> bool           val ( <= ) : t -> t -> bool           val ( = ) : t -> t -> bool           val ( > ) : t -> t -> bool           val ( < ) : t -> t -> bool           val ( <> ) : t -> t -> bool           val equal : t -> t -> bool           val min : t -> t -> t           val max : t -> t -> t           val ascending : t -> t -> int           val descending : t -> t -> int           val between : t -> low:t -> high:t -> bool           val clamp_exn : t -> min:t -> max:t -> t           val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t           module Replace_polymorphic_compare :             sig               val ( >= ) : t -> t -> bool               val ( <= ) : t -> t -> bool               val ( = ) : t -> t -> bool               val ( > ) : t -> t -> bool               val ( < ) : t -> t -> bool               val ( <> ) : t -> t -> bool               val equal : t -> t -> bool               val compare : t -> t -> int               val min : t -> t -> t               val max : t -> t -> t             end           type comparator_witness           val comparator :             (t, comparator_witness) Core_kernel.Comparator.comparator           val validate_lbound :             min:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_ubound :             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_bound :             min:t Core_kernel.Maybe_bound.t ->             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           module Map :             sig               module Key :                 sig                   type t = Edge.graph                   type comparator_witness = comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type 'a t =                       (Key.t, 'a, comparator_witness)                       Core_kernel.Core_map.Tree.t                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val empty : 'a t                   val singleton : Key.t -> '-> 'a t                   val of_alist :                     (Key.t * 'a) list ->                     [ `Duplicate_key of Key.t | `Ok of 'a t ]                   val of_alist_or_error :                     (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                   val of_alist_exn : (Key.t * 'a) list -> 'a t                   val of_alist_multi : (Key.t * 'a) list -> 'a list t                   val of_alist_fold :                     (Key.t * 'a) list ->                     init:'-> f:('-> '-> 'b) -> 'b t                   val of_alist_reduce :                     (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                   val of_sorted_array :                     (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t                   val of_tree : 'a t -> 'a t                   val gen :                     Key.t Core_kernel.Quickcheck.Generator.t ->                     'Core_kernel.Quickcheck.Generator.t ->                     'a t Core_kernel.Quickcheck.Generator.t                   val invariants : 'a t -> bool                   val is_empty : 'a t -> bool                   val length : 'a t -> int                   val add : 'a t -> key:Key.t -> data:'-> 'a t                   val add_multi :                     'a list t -> key:Key.t -> data:'-> 'a list t                   val remove_multi : 'a list t -> Key.t -> 'a list t                   val change :                     'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                   val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                   val find : 'a t -> Key.t -> 'a option                   val find_exn : 'a t -> Key.t -> 'a                   val remove : 'a t -> Key.t -> 'a t                   val mem : 'a t -> Key.t -> bool                   val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iteri :                     'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                   val iter2 :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        unit) ->                     unit                   val map : 'a t -> f:('-> 'b) -> 'b t                   val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                   val fold :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold_right :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold2 :                     'a t ->                     'b t ->                     init:'->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        '-> 'c) ->                     'c                   val filter :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filteri :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                   val filter_map : 'a t -> f:('-> 'b option) -> 'b t                   val filter_mapi :                     'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                   val partition_mapi :                     'a t ->                     f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                     'b t * 'c t                   val partition_map :                     'a t ->                     f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                   val partitioni_tf :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                   val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                   val compare_direct :                     ('-> '-> int) -> 'a t -> 'a t -> int                   val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                   val keys : 'a t -> Key.t list                   val data : 'a t -> 'a list                   val to_alist :                     ?key_order:[ `Decreasing | `Increasing ] ->                     'a t -> (Key.t * 'a) list                   val validate :                     name:(Key.t -> string) ->                     'Core_kernel.Validate.check ->                     'a t Core_kernel.Validate.check                   val merge :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        'c option) ->                     'c t                   val symmetric_diff :                     'a t ->                     'a t ->                     data_equal:('-> '-> bool) ->                     (Key.t, 'a)                     Core_kernel.Core_map_intf.Symmetric_diff_element.t                     Core_kernel.Sequence.t                   val min_elt : 'a t -> (Key.t * 'a) option                   val min_elt_exn : 'a t -> Key.t * 'a                   val max_elt : 'a t -> (Key.t * 'a) option                   val max_elt_exn : 'a t -> Key.t * 'a                   val for_all : 'a t -> f:('-> bool) -> bool                   val for_alli :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val exists : 'a t -> f:('-> bool) -> bool                   val existsi :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val counti :                     'a t -> f:(key:Key.t -> data:'-> bool) -> int                   val split :                     'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                   val fold_range_inclusive :                     'a t ->                     min:Key.t ->                     max:Key.t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val range_to_alist :                     'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                   val closest_key :                     'a t ->                     [ `Greater_or_equal_to                     | `Greater_than                     | `Less_or_equal_to                     | `Less_than ] -> Key.t -> (Key.t * 'a) option                   val nth : 'a t -> int -> (Key.t * 'a) option                   val rank : 'a t -> Key.t -> int option                   val to_tree : 'a t -> 'a t                   val to_sequence :                     ?order:[ `Decreasing_key | `Increasing_key ] ->                     ?keys_greater_or_equal_to:Key.t ->                     ?keys_less_or_equal_to:Key.t ->                     'a t -> (Key.t * 'a) Core_kernel.Sequence.t                   val obs :                     Key.t Core_kernel.Quickcheck.Observer.t ->                     'Core_kernel.Quickcheck.Observer.t ->                     'v t Core_kernel.Quickcheck.Observer.t                   val shrinker :                     Key.t Core_kernel.Quickcheck.Shrinker.t ->                     'Core_kernel.Quickcheck.Shrinker.t ->                     'v t Core_kernel.Quickcheck.Shrinker.t                 end               type 'a t =                   (Key.t, 'a, comparator_witness) Core_kernel.Core_map.t               val t_of_sexp :                 (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val compare : ('-> '-> int) -> 'a t -> 'a t -> int               val empty : 'a t               val singleton : Key.t -> '-> 'a t               val of_alist :                 (Key.t * 'a) list ->                 [ `Duplicate_key of Key.t | `Ok of 'a t ]               val of_alist_or_error :                 (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t               val of_alist_exn : (Key.t * 'a) list -> 'a t               val of_alist_multi : (Key.t * 'a) list -> 'a list t               val of_alist_fold :                 (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t               val of_alist_reduce :                 (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t               val of_sorted_array :                 (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t               val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t               val of_tree : 'Tree.t -> 'a t               val gen :                 Key.t Core_kernel.Quickcheck.Generator.t ->                 'Core_kernel.Quickcheck.Generator.t ->                 'a t Core_kernel.Quickcheck.Generator.t               val invariants : 'a t -> bool               val is_empty : 'a t -> bool               val length : 'a t -> int               val add : 'a t -> key:Key.t -> data:'-> 'a t               val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t               val remove_multi : 'a list t -> Key.t -> 'a list t               val change :                 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t               val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t               val find : 'a t -> Key.t -> 'a option               val find_exn : 'a t -> Key.t -> 'a               val remove : 'a t -> Key.t -> 'a t               val mem : 'a t -> Key.t -> bool               val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(Key.t -> unit) -> unit               val iter2 :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    unit) ->                 unit               val map : 'a t -> f:('-> 'b) -> 'b t               val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t               val fold :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold_right :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold2 :                 'a t ->                 'b t ->                 init:'->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    '-> 'c) ->                 'c               val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t               val filter_map : 'a t -> f:('-> 'b option) -> 'b t               val filter_mapi :                 'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t               val partition_mapi :                 'a t ->                 f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                 'b t * 'c t               val partition_map :                 'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t               val partitioni_tf :                 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t               val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t               val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int               val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool               val keys : 'a t -> Key.t list               val data : 'a t -> 'a list               val to_alist :                 ?key_order:[ `Decreasing | `Increasing ] ->                 'a t -> (Key.t * 'a) list               val validate :                 name:(Key.t -> string) ->                 'Core_kernel.Validate.check ->                 'a t Core_kernel.Validate.check               val merge :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    'c option) ->                 'c t               val symmetric_diff :                 'a t ->                 'a t ->                 data_equal:('-> '-> bool) ->                 (Key.t, 'a)                 Core_kernel.Core_map_intf.Symmetric_diff_element.t                 Core_kernel.Sequence.t               val min_elt : 'a t -> (Key.t * 'a) option               val min_elt_exn : 'a t -> Key.t * 'a               val max_elt : 'a t -> (Key.t * 'a) option               val max_elt_exn : 'a t -> Key.t * 'a               val for_all : 'a t -> f:('-> bool) -> bool               val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val exists : 'a t -> f:('-> bool) -> bool               val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int               val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t               val fold_range_inclusive :                 'a t ->                 min:Key.t ->                 max:Key.t ->                 init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val range_to_alist :                 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list               val closest_key :                 'a t ->                 [ `Greater_or_equal_to                 | `Greater_than                 | `Less_or_equal_to                 | `Less_than ] -> Key.t -> (Key.t * 'a) option               val nth : 'a t -> int -> (Key.t * 'a) option               val rank : 'a t -> Key.t -> int option               val to_tree : 'a t -> 'Tree.t               val to_sequence :                 ?order:[ `Decreasing_key | `Increasing_key ] ->                 ?keys_greater_or_equal_to:Key.t ->                 ?keys_less_or_equal_to:Key.t ->                 'a t -> (Key.t * 'a) Core_kernel.Sequence.t               val obs :                 Key.t Core_kernel.Quickcheck.Observer.t ->                 'Core_kernel.Quickcheck.Observer.t ->                 'v t Core_kernel.Quickcheck.Observer.t               val shrinker :                 Key.t Core_kernel.Quickcheck.Shrinker.t ->                 'Core_kernel.Quickcheck.Shrinker.t ->                 'v t Core_kernel.Quickcheck.Shrinker.t             end           module Set :             sig               module Elt :                 sig                   type t = Edge.graph                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   type comparator_witness = Map.Key.comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type t =                       (Elt.t, comparator_witness) Core_kernel.Core_set.Tree.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val length : t -> int                   val is_empty : t -> bool                   val iter : t -> f:(Elt.t -> unit) -> unit                   val fold :                     t ->                     init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                   val exists : t -> f:(Elt.t -> bool) -> bool                   val for_all : t -> f:(Elt.t -> bool) -> bool                   val count : t -> f:(Elt.t -> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     t -> f:(Elt.t -> 'sum) -> 'sum                   val find : t -> f:(Elt.t -> bool) -> Elt.t option                   val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                   val to_list : t -> Elt.t list                   val to_array : t -> Elt.t array                   val invariants : t -> bool                   val mem : t -> Elt.t -> bool                   val add : t -> Elt.t -> t                   val remove : t -> Elt.t -> t                   val union : t -> t -> t                   val inter : t -> t -> t                   val diff : t -> t -> t                   val symmetric_diff :                     t ->                     t ->                     (Elt.t, Elt.t) Core_kernel.Either.t                     Core_kernel.Sequence.t                   val compare_direct : t -> t -> int                   val equal : t -> t -> bool                   val subset : t -> t -> bool                   val fold_until :                     t ->                     init:'->                     f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                     'b                   val fold_right :                     t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                   val iter2 :                     t ->                     t ->                     f:([ `Both of Elt.t * Elt.t                        | `Left of Elt.t                        | `Right of Elt.t ] -> unit) ->                     unit                   val filter : t -> f:(Elt.t -> bool) -> t                   val partition_tf : t -> f:(Elt.t -> bool) -> t * t                   val elements : t -> Elt.t list                   val min_elt : t -> Elt.t option                   val min_elt_exn : t -> Elt.t                   val max_elt : t -> Elt.t option                   val max_elt_exn : t -> Elt.t                   val choose : t -> Elt.t option                   val choose_exn : t -> Elt.t                   val split : t -> Elt.t -> t * Elt.t option * t                   val group_by :                     t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                   val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                   val find_index : t -> int -> Elt.t option                   val remove_index : t -> int -> t                   val to_tree : t -> t                   val to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t -> Elt.t Core_kernel.Sequence.t                   val merge_to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t ->                     t ->                     Elt.t                     Core_kernel.Core_set_intf.Merge_to_sequence_element.t                     Core_kernel.Sequence.t                   val to_map :                     t ->                     f:(Elt.t -> 'data) ->                     (Elt.t, 'data, comparator_witness)                     Core_kernel.Core_set_intf.Map.t                   val obs :                     Elt.t Core_kernel.Quickcheck.obs ->                     t Core_kernel.Quickcheck.obs                   val shrinker :                     Elt.t Core_kernel.Quickcheck.shr ->                     t Core_kernel.Quickcheck.shr                   val empty : t                   val singleton : Elt.t -> t                   val union_list : t list -> t                   val of_list : Elt.t list -> t                   val of_array : Elt.t array -> t                   val of_sorted_array :                     Elt.t array -> t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : Elt.t array -> t                   val stable_dedup_list : Elt.t list -> Elt.t list                   val map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t) -> t                   val filter_map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t option) -> t                   val of_tree : t -> t                   val of_map_keys :                     (Elt.t, 'a, comparator_witness)                     Core_kernel.Core_set_intf.Map.t -> t                   val gen :                     Elt.t Core_kernel.Quickcheck.Generator.t ->                     t Core_kernel.Quickcheck.Generator.t                 end               type t = (Elt.t, comparator_witness) Core_kernel.Core_set.t               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               val compare : t -> t -> int               val length : t -> int               val is_empty : t -> bool               val iter : t -> f:(Elt.t -> unit) -> unit               val fold :                 t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum               val exists : t -> f:(Elt.t -> bool) -> bool               val for_all : t -> f:(Elt.t -> bool) -> bool               val count : t -> f:(Elt.t -> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 t -> f:(Elt.t -> 'sum) -> 'sum               val find : t -> f:(Elt.t -> bool) -> Elt.t option               val find_map : t -> f:(Elt.t -> 'a option) -> 'a option               val to_list : t -> Elt.t list               val to_array : t -> Elt.t array               val invariants : t -> bool               val mem : t -> Elt.t -> bool               val add : t -> Elt.t -> t               val remove : t -> Elt.t -> t               val union : t -> t -> t               val inter : t -> t -> t               val diff : t -> t -> t               val symmetric_diff :                 t ->                 t ->                 (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t               val compare_direct : t -> t -> int               val equal : t -> t -> bool               val subset : t -> t -> bool               val fold_until :                 t ->                 init:'->                 f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b               val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b               val iter2 :                 t ->                 t ->                 f:([ `Both of Elt.t * Elt.t                    | `Left of Elt.t                    | `Right of Elt.t ] -> unit) ->                 unit               val filter : t -> f:(Elt.t -> bool) -> t               val partition_tf : t -> f:(Elt.t -> bool) -> t * t               val elements : t -> Elt.t list               val min_elt : t -> Elt.t option               val min_elt_exn : t -> Elt.t               val max_elt : t -> Elt.t option               val max_elt_exn : t -> Elt.t               val choose : t -> Elt.t option               val choose_exn : t -> Elt.t               val split : t -> Elt.t -> t * Elt.t option * t               val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list               val find_exn : t -> f:(Elt.t -> bool) -> Elt.t               val find_index : t -> int -> Elt.t option               val remove_index : t -> int -> t               val to_tree : t -> Tree.t               val to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t               val merge_to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t ->                 t ->                 t ->                 Elt.t Core_kernel.Core_set_intf.Merge_to_sequence_element.t                 Core_kernel.Sequence.t               val to_map :                 t ->                 f:(Elt.t -> 'data) ->                 (Elt.t, 'data, comparator_witness)                 Core_kernel.Core_set_intf.Map.t               val obs :                 Elt.t Core_kernel.Quickcheck.obs ->                 t Core_kernel.Quickcheck.obs               val shrinker :                 Elt.t Core_kernel.Quickcheck.shr ->                 t Core_kernel.Quickcheck.shr               val empty : t               val singleton : Elt.t -> t               val union_list : t list -> t               val of_list : Elt.t list -> t               val of_array : Elt.t array -> t               val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t               val of_sorted_array_unchecked : Elt.t array -> t               val stable_dedup_list : Elt.t list -> Elt.t list               val map :                 ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t               val filter_map :                 ('a, 'b) Core_kernel.Core_set.t ->                 f:('-> Elt.t option) -> t               val of_tree : Tree.t -> t               val of_map_keys :                 (Elt.t, 'a, comparator_witness)                 Core_kernel.Core_set_intf.Map.t -> t               val gen :                 Elt.t Core_kernel.Quickcheck.Generator.t ->                 t Core_kernel.Quickcheck.Generator.t             end           val hash : t -> int           val compare : t -> t -> int           val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t           module Table :             sig               type key = t               type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl               type 'b t = (key, 'b) hashtbl               val t_of_sexp :                 (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t               type ('a, 'b) t_ = 'b t               type 'a key_ = key               val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t               val invariant :                 'Core_kernel.Invariant_intf.inv ->                 'a t Core_kernel.Invariant_intf.inv               val create :                 (key, 'b, unit -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist :                 (key, 'b,                  (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_report_all_dups :                 (key, 'b,                  (key * 'b) list ->                  [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_or_error :                 (key, 'b, (key * 'b) list -> 'b t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_exn :                 (key, 'b, (key * 'b) list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_multi :                 (key, 'b list, (key * 'b) list -> 'b list t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_mapped :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_or_error :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> 'r t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_exn :                 (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val group :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  combine:('-> '-> 'b) -> 'r list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t               val clear : 'a t -> unit               val copy : 'b t -> 'b t               val fold :                 'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c               val iter_vals : 'b t -> f:('-> unit) -> unit               val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(key -> unit) -> unit               val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit               val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool               val exists : 'b t -> f:('-> bool) -> bool               val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool               val for_all : 'b t -> f:('-> bool) -> bool               val counti : 'b t -> f:(key:key -> data:'-> bool) -> int               val count : 'b t -> f:('-> bool) -> int               val length : 'a t -> int               val is_empty : 'a t -> bool               val mem : 'a t -> key -> bool               val remove : 'a t -> key -> unit               val replace : 'b t -> key:key -> data:'-> unit               val set : 'b t -> key:key -> data:'-> unit               val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]               val add_or_error :                 'b t -> key:key -> data:'-> unit Core_kernel.Or_error.t               val add_exn : 'b t -> key:key -> data:'-> unit               val change : 'b t -> key -> f:('b option -> 'b option) -> unit               val update : 'b t -> key -> f:('b option -> 'b) -> unit               val add_multi : 'b list t -> key:key -> data:'-> unit               val remove_multi : 'a list t -> key -> unit               val map :                 ('c, 'b t -> f:('-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_map :                 ('c, 'b t -> f:('-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter : 'b t -> f:('-> bool) -> 'b t               val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t               val partition_map :                 ('c,                  ('d,                   'b t ->                   f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_mapi :                 ('c,                  ('d,                   'b t ->                   f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                   'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t               val partitioni_tf :                 'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t               val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b               val find : 'b t -> key -> 'b option               val find_exn : 'b t -> key -> 'b               val find_and_call :                 'b t ->                 key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c               val find_and_remove : 'b t -> key -> 'b option               val merge :                 ('c,                  'a t ->                  'b t ->                  f:(key:key ->                     [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                     'c option) ->                  'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               type 'a merge_into_action = Remove | Set_to of 'a               val merge_into :                 src:'a t ->                 dst:'b t ->                 f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                 unit               val keys : 'a t -> key list               val data : 'b t -> 'b list               val filter_inplace : 'b t -> f:('-> bool) -> unit               val filteri_inplace :                 'b t -> f:(key:key -> data:'-> bool) -> unit               val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit               val map_inplace : 'b t -> f:('-> 'b) -> unit               val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit               val filter_mapi_inplace :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val replace_all : 'b t -> f:('-> 'b) -> unit               val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_replace_all : 'b t -> f:('-> 'b option) -> unit               val filter_replace_alli :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool               val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool               val to_alist : 'b t -> (key * 'b) list               val validate :                 name:(key -> string) ->                 'Core_kernel.Validate.check ->                 'b t Core_kernel.Validate.check               val incr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit               val decr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit             end           module Hash_set :             sig               type elt = t               type 'a hash_set = 'Edge.Hash_set.hash_set               type t = elt hash_set               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               type 'a t_ = t               type 'a elt_ = elt               val create :                 ('a, unit -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable               val of_list :                 ('a, elt list -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable             end           module Hash_queue :             sig               module Key :                 sig                   type t = Hash_set.elt                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val hash : t -> int                 end               type 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val length : 'a t -> int               val is_empty : 'a t -> bool               val iter : 'a t -> f:('-> unit) -> unit               val fold :                 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum               val exists : 'a t -> f:('-> bool) -> bool               val for_all : 'a t -> f:('-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 'a t -> f:('-> 'sum) -> 'sum               val find : 'a t -> f:('-> bool) -> 'a option               val find_map : 'a t -> f:('-> 'b option) -> 'b option               val to_list : 'a t -> 'a list               val to_array : 'a t -> 'a array               val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val invariant : 'a t -> unit               val create : ?growth_allowed:bool -> ?size:int -> unit -> 'a t               val clear : 'a t -> unit               val mem : 'a t -> Key.t -> bool               val lookup : 'a t -> Key.t -> 'a option               val lookup_exn : 'a t -> Key.t -> 'a               val enqueue :                 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]               val enqueue_exn : 'a t -> Key.t -> '-> unit               val first : 'a t -> 'a option               val first_with_key : 'a t -> (Key.t * 'a) option               val keys : 'a t -> Key.t list               val dequeue : 'a t -> 'a option               val dequeue_exn : 'a t -> 'a               val dequeue_with_key : 'a t -> (Key.t * 'a) option               val dequeue_with_key_exn : 'a t -> Key.t * 'a               val dequeue_all : 'a t -> f:('-> unit) -> unit               val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]               val remove_exn : 'a t -> Key.t -> unit               val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]               val replace_exn : 'a t -> Key.t -> '-> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val foldi :                 'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b             end           val to_string : t -> string           val str : unit -> t -> string           val pps : unit -> t -> string           val ppo : Core_kernel.Std.out_channel -> t -> unit           val pp_seq :             Format.formatter -> t Core_kernel.Std.Sequence.t -> unit           val pp : Format.formatter -> t -> unit         end       type ('c, 'n, 'e) graph =           (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c)       type edge_kind = [ `Back | `Cross | `Forward | `Tree ]       type 'a tree       type 'a frontier       type 'a partition       type 'a group       type 'a path       type equiv       module Tree :         sig           type 'a t = 'Graphlib.Std.tree           val children : 'Graphlib.Std.Tree.t -> '-> 'Regular.Std.seq           val parent : 'Graphlib.Std.Tree.t -> '-> 'a option           val ancestors : 'Graphlib.Std.Tree.t -> '-> 'Regular.Std.seq           val descendants :             'Graphlib.Std.Tree.t -> '-> 'Regular.Std.seq           val is_child_of : 'Graphlib.Std.Tree.t -> parent:'-> '-> bool           val is_ancestor_of :             'Graphlib.Std.Tree.t -> child:'-> '-> bool           val is_descendant_of :             'Graphlib.Std.Tree.t -> parent:'-> '-> bool           val to_sequence : 'Graphlib.Std.Tree.t -> 'Regular.Std.seq           val pp :             'Regular.Std.printer ->             'Graphlib.Std.Tree.t Regular.Std.printer         end       module Frontier :         sig           type 'a t = 'Graphlib.Std.frontier           val enum : 'Graphlib.Std.Frontier.t -> '-> 'Regular.Std.seq           val mem : 'Graphlib.Std.Frontier.t -> '-> '-> bool           val to_sequence : 'Graphlib.Std.Frontier.t -> 'Regular.Std.seq           val pp :             'Regular.Std.printer ->             'Graphlib.Std.Frontier.t Regular.Std.printer         end       module Path :         sig           type 'e t = 'Graphlib.Std.path           val start : 'Graphlib.Std.Path.t -> 'e           val finish : 'Graphlib.Std.Path.t -> 'e           val edges : 'Graphlib.Std.Path.t -> 'Regular.Std.seq           val edges_rev : 'Graphlib.Std.Path.t -> 'Regular.Std.seq           val weight : 'Graphlib.Std.Path.t -> int           val length : 'Graphlib.Std.Path.t -> int           val pp :             'Regular.Std.printer ->             'Graphlib.Std.Path.t Regular.Std.printer         end       module Partition :         sig           type 'a t = 'Graphlib.Std.partition           val groups :             'Graphlib.Std.Partition.t ->             'Graphlib.Std.group Regular.Std.seq           val group :             'Graphlib.Std.Partition.t -> '-> 'Graphlib.Std.group option           val equiv : 'Graphlib.Std.Partition.t -> '-> '-> bool           val number_of_groups : 'Graphlib.Std.Partition.t -> int           val of_equiv :             'Graphlib.Std.Partition.t ->             Graphlib.Std.equiv -> 'Graphlib.Std.group option           val pp :             'Regular.Std.printer ->             'Graphlib.Std.Partition.t Regular.Std.printer         end       module Group :         sig           type 'a t = 'Graphlib.Std.group           val enum : 'Graphlib.Std.group -> 'Regular.Std.seq           val mem : 'Graphlib.Std.group -> '-> bool           val top : 'Graphlib.Std.group -> 'a           val to_equiv : 'Graphlib.Std.group -> Graphlib.Std.equiv           val pp :             'Regular.Std.printer ->             'Graphlib.Std.Group.t Regular.Std.printer         end       module Equiv :         sig           type t           val to_int : Graphlib.Std.Equiv.t -> int           val t_of_sexp : Sexplib.Sexp.t -> t           val sexp_of_t : t -> Sexplib.Sexp.t           val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t           val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader           val __bin_read_t__ :             (int -> t) Core_kernel.Std.Bin_prot.Read.reader           val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader           val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer           val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer           val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer           val to_string : t -> string           val str : unit -> t -> string           val pps : unit -> t -> string           val ppo : Core_kernel.Std.out_channel -> t -> unit           val pp_seq :             Format.formatter -> t Core_kernel.Std.Sequence.t -> unit           val pp : Format.formatter -> t -> unit           val ( >= ) : t -> t -> bool           val ( <= ) : t -> t -> bool           val ( = ) : t -> t -> bool           val ( > ) : t -> t -> bool           val ( < ) : t -> t -> bool           val ( <> ) : t -> t -> bool           val equal : t -> t -> bool           val compare : t -> t -> int           val min : t -> t -> t           val max : t -> t -> t           val ascending : t -> t -> int           val descending : t -> t -> int           val between : t -> low:t -> high:t -> bool           val clamp_exn : t -> min:t -> max:t -> t           val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t           module Replace_polymorphic_compare :             sig               val ( >= ) : t -> t -> bool               val ( <= ) : t -> t -> bool               val ( = ) : t -> t -> bool               val ( > ) : t -> t -> bool               val ( < ) : t -> t -> bool               val ( <> ) : t -> t -> bool               val equal : t -> t -> bool               val compare : t -> t -> int               val min : t -> t -> t               val max : t -> t -> t             end           type comparator_witness           val validate_lbound :             min:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_ubound :             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val validate_bound :             min:t Core_kernel.Maybe_bound.t ->             max:t Core_kernel.Maybe_bound.t -> t Core_kernel.Validate.check           val comparator :             (t, comparator_witness) Core_kernel.Comparator.comparator           module Map :             sig               module Key :                 sig                   type t = t                   type comparator_witness = comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type 'a t =                       (Key.t, 'a, comparator_witness)                       Core_kernel.Core_map.Tree.t                   val t_of_sexp :                     (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                   val sexp_of_t :                     ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                   val empty : 'a t                   val singleton : Key.t -> '-> 'a t                   val of_alist :                     (Key.t * 'a) list ->                     [ `Duplicate_key of Key.t | `Ok of 'a t ]                   val of_alist_or_error :                     (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                   val of_alist_exn : (Key.t * 'a) list -> 'a t                   val of_alist_multi : (Key.t * 'a) list -> 'a list t                   val of_alist_fold :                     (Key.t * 'a) list ->                     init:'-> f:('-> '-> 'b) -> 'b t                   val of_alist_reduce :                     (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                   val of_sorted_array :                     (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t                   val of_tree : 'a t -> 'a t                   val gen :                     Key.t Core_kernel.Quickcheck.Generator.t ->                     'Core_kernel.Quickcheck.Generator.t ->                     'a t Core_kernel.Quickcheck.Generator.t                   val invariants : 'a t -> bool                   val is_empty : 'a t -> bool                   val length : 'a t -> int                   val add : 'a t -> key:Key.t -> data:'-> 'a t                   val add_multi :                     'a list t -> key:Key.t -> data:'-> 'a list t                   val remove_multi : 'a list t -> Key.t -> 'a list t                   val change :                     'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                   val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                   val find : 'a t -> Key.t -> 'a option                   val find_exn : 'a t -> Key.t -> 'a                   val remove : 'a t -> Key.t -> 'a t                   val mem : 'a t -> Key.t -> bool                   val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iteri :                     'a t -> f:(key:Key.t -> data:'-> unit) -> unit                   val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                   val iter2 :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        unit) ->                     unit                   val map : 'a t -> f:('-> 'b) -> 'b t                   val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                   val fold :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold_right :                     'a t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val fold2 :                     'a t ->                     'b t ->                     init:'->                     f:(key:Key.t ->                        data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        '-> 'c) ->                     'c                   val filter :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filteri :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                   val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                   val filter_map : 'a t -> f:('-> 'b option) -> 'b t                   val filter_mapi :                     'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                   val partition_mapi :                     'a t ->                     f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                     'b t * 'c t                   val partition_map :                     'a t ->                     f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                   val partitioni_tf :                     'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                   val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                   val compare_direct :                     ('-> '-> int) -> 'a t -> 'a t -> int                   val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                   val keys : 'a t -> Key.t list                   val data : 'a t -> 'a list                   val to_alist :                     ?key_order:[ `Decreasing | `Increasing ] ->                     'a t -> (Key.t * 'a) list                   val validate :                     name:(Key.t -> string) ->                     'Core_kernel.Validate.check ->                     'a t Core_kernel.Validate.check                   val merge :                     'a t ->                     'b t ->                     f:(key:Key.t ->                        [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                        'c option) ->                     'c t                   val symmetric_diff :                     'a t ->                     'a t ->                     data_equal:('-> '-> bool) ->                     (Key.t, 'a)                     Core_kernel.Core_map_intf.Symmetric_diff_element.t                     Core_kernel.Sequence.t                   val min_elt : 'a t -> (Key.t * 'a) option                   val min_elt_exn : 'a t -> Key.t * 'a                   val max_elt : 'a t -> (Key.t * 'a) option                   val max_elt_exn : 'a t -> Key.t * 'a                   val for_all : 'a t -> f:('-> bool) -> bool                   val for_alli :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val exists : 'a t -> f:('-> bool) -> bool                   val existsi :                     'a t -> f:(key:Key.t -> data:'-> bool) -> bool                   val count : 'a t -> f:('-> bool) -> int                   val counti :                     'a t -> f:(key:Key.t -> data:'-> bool) -> int                   val split :                     'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                   val fold_range_inclusive :                     'a t ->                     min:Key.t ->                     max:Key.t ->                     init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                   val range_to_alist :                     'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                   val closest_key :                     'a t ->                     [ `Greater_or_equal_to                     | `Greater_than                     | `Less_or_equal_to                     | `Less_than ] -> Key.t -> (Key.t * 'a) option                   val nth : 'a t -> int -> (Key.t * 'a) option                   val rank : 'a t -> Key.t -> int option                   val to_tree : 'a t -> 'a t                   val to_sequence :                     ?order:[ `Decreasing_key | `Increasing_key ] ->                     ?keys_greater_or_equal_to:Key.t ->                     ?keys_less_or_equal_to:Key.t ->                     'a t -> (Key.t * 'a) Core_kernel.Sequence.t                   val obs :                     Key.t Core_kernel.Quickcheck.Observer.t ->                     'Core_kernel.Quickcheck.Observer.t ->                     'v t Core_kernel.Quickcheck.Observer.t                   val shrinker :                     Key.t Core_kernel.Quickcheck.Shrinker.t ->                     'Core_kernel.Quickcheck.Shrinker.t ->                     'v t Core_kernel.Quickcheck.Shrinker.t                 end               type 'a t =                   (Key.t, 'a, comparator_witness) Core_kernel.Core_map.t               val t_of_sexp :                 (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val compare : ('-> '-> int) -> 'a t -> 'a t -> int               val empty : 'a t               val singleton : Key.t -> '-> 'a t               val of_alist :                 (Key.t * 'a) list ->                 [ `Duplicate_key of Key.t | `Ok of 'a t ]               val of_alist_or_error :                 (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t               val of_alist_exn : (Key.t * 'a) list -> 'a t               val of_alist_multi : (Key.t * 'a) list -> 'a list t               val of_alist_fold :                 (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t               val of_alist_reduce :                 (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t               val of_sorted_array :                 (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t               val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t               val of_tree : 'Tree.t -> 'a t               val gen :                 Key.t Core_kernel.Quickcheck.Generator.t ->                 'Core_kernel.Quickcheck.Generator.t ->                 'a t Core_kernel.Quickcheck.Generator.t               val invariants : 'a t -> bool               val is_empty : 'a t -> bool               val length : 'a t -> int               val add : 'a t -> key:Key.t -> data:'-> 'a t               val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t               val remove_multi : 'a list t -> Key.t -> 'a list t               val change :                 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t               val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t               val find : 'a t -> Key.t -> 'a option               val find_exn : 'a t -> Key.t -> 'a               val remove : 'a t -> Key.t -> 'a t               val mem : 'a t -> Key.t -> bool               val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(Key.t -> unit) -> unit               val iter2 :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    unit) ->                 unit               val map : 'a t -> f:('-> 'b) -> 'b t               val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t               val fold :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold_right :                 'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val fold2 :                 'a t ->                 'b t ->                 init:'->                 f:(key:Key.t ->                    data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    '-> 'c) ->                 'c               val filter : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t               val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t               val filter_map : 'a t -> f:('-> 'b option) -> 'b t               val filter_mapi :                 'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t               val partition_mapi :                 'a t ->                 f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                 'b t * 'c t               val partition_map :                 'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t               val partitioni_tf :                 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t               val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t               val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int               val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool               val keys : 'a t -> Key.t list               val data : 'a t -> 'a list               val to_alist :                 ?key_order:[ `Decreasing | `Increasing ] ->                 'a t -> (Key.t * 'a) list               val validate :                 name:(Key.t -> string) ->                 'Core_kernel.Validate.check ->                 'a t Core_kernel.Validate.check               val merge :                 'a t ->                 'b t ->                 f:(key:Key.t ->                    [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                    'c option) ->                 'c t               val symmetric_diff :                 'a t ->                 'a t ->                 data_equal:('-> '-> bool) ->                 (Key.t, 'a)                 Core_kernel.Core_map_intf.Symmetric_diff_element.t                 Core_kernel.Sequence.t               val min_elt : 'a t -> (Key.t * 'a) option               val min_elt_exn : 'a t -> Key.t * 'a               val max_elt : 'a t -> (Key.t * 'a) option               val max_elt_exn : 'a t -> Key.t * 'a               val for_all : 'a t -> f:('-> bool) -> bool               val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val exists : 'a t -> f:('-> bool) -> bool               val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int               val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t               val fold_range_inclusive :                 'a t ->                 min:Key.t ->                 max:Key.t ->                 init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b               val range_to_alist :                 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list               val closest_key :                 'a t ->                 [ `Greater_or_equal_to                 | `Greater_than                 | `Less_or_equal_to                 | `Less_than ] -> Key.t -> (Key.t * 'a) option               val nth : 'a t -> int -> (Key.t * 'a) option               val rank : 'a t -> Key.t -> int option               val to_tree : 'a t -> 'Tree.t               val to_sequence :                 ?order:[ `Decreasing_key | `Increasing_key ] ->                 ?keys_greater_or_equal_to:Key.t ->                 ?keys_less_or_equal_to:Key.t ->                 'a t -> (Key.t * 'a) Core_kernel.Sequence.t               val obs :                 Key.t Core_kernel.Quickcheck.Observer.t ->                 'Core_kernel.Quickcheck.Observer.t ->                 'v t Core_kernel.Quickcheck.Observer.t               val shrinker :                 Key.t Core_kernel.Quickcheck.Shrinker.t ->                 'Core_kernel.Quickcheck.Shrinker.t ->                 'v t Core_kernel.Quickcheck.Shrinker.t               val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1               val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1               val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1               val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1               val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer               val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader               val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t             end           module Set :             sig               module Elt :                 sig                   type t = Map.Key.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   type comparator_witness = Map.Key.comparator_witness                   val comparator :                     (t, comparator_witness) Core_kernel.Comparator.comparator                 end               module Tree :                 sig                   type t =                       (Elt.t, comparator_witness) Core_kernel.Core_set.Tree.t                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val length : t -> int                   val is_empty : t -> bool                   val iter : t -> f:(Elt.t -> unit) -> unit                   val fold :                     t ->                     init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                   val exists : t -> f:(Elt.t -> bool) -> bool                   val for_all : t -> f:(Elt.t -> bool) -> bool                   val count : t -> f:(Elt.t -> bool) -> int                   val sum :                     (module Core_kernel.Commutative_group.S with type t = 'sum) ->                     t -> f:(Elt.t -> 'sum) -> 'sum                   val find : t -> f:(Elt.t -> bool) -> Elt.t option                   val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                   val to_list : t -> Elt.t list                   val to_array : t -> Elt.t array                   val invariants : t -> bool                   val mem : t -> Elt.t -> bool                   val add : t -> Elt.t -> t                   val remove : t -> Elt.t -> t                   val union : t -> t -> t                   val inter : t -> t -> t                   val diff : t -> t -> t                   val symmetric_diff :                     t ->                     t ->                     (Elt.t, Elt.t) Core_kernel.Either.t                     Core_kernel.Sequence.t                   val compare_direct : t -> t -> int                   val equal : t -> t -> bool                   val subset : t -> t -> bool                   val fold_until :                     t ->                     init:'->                     f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                     'b                   val fold_right :                     t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                   val iter2 :                     t ->                     t ->                     f:([ `Both of Elt.t * Elt.t                        | `Left of Elt.t                        | `Right of Elt.t ] -> unit) ->                     unit                   val filter : t -> f:(Elt.t -> bool) -> t                   val partition_tf : t -> f:(Elt.t -> bool) -> t * t                   val elements : t -> Elt.t list                   val min_elt : t -> Elt.t option                   val min_elt_exn : t -> Elt.t                   val max_elt : t -> Elt.t option                   val max_elt_exn : t -> Elt.t                   val choose : t -> Elt.t option                   val choose_exn : t -> Elt.t                   val split : t -> Elt.t -> t * Elt.t option * t                   val group_by :                     t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                   val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                   val find_index : t -> int -> Elt.t option                   val remove_index : t -> int -> t                   val to_tree : t -> t                   val to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t -> Elt.t Core_kernel.Sequence.t                   val merge_to_sequence :                     ?order:[ `Decreasing | `Increasing ] ->                     ?greater_or_equal_to:Elt.t ->                     ?less_or_equal_to:Elt.t ->                     t ->                     t ->                     Elt.t                     Core_kernel.Core_set_intf.Merge_to_sequence_element.t                     Core_kernel.Sequence.t                   val to_map :                     t ->                     f:(Elt.t -> 'data) ->                     (Elt.t, 'data, comparator_witness)                     Core_kernel.Core_set_intf.Map.t                   val obs :                     Elt.t Core_kernel.Quickcheck.obs ->                     t Core_kernel.Quickcheck.obs                   val shrinker :                     Elt.t Core_kernel.Quickcheck.shr ->                     t Core_kernel.Quickcheck.shr                   val empty : t                   val singleton : Elt.t -> t                   val union_list : t list -> t                   val of_list : Elt.t list -> t                   val of_array : Elt.t array -> t                   val of_sorted_array :                     Elt.t array -> t Core_kernel.Or_error.t                   val of_sorted_array_unchecked : Elt.t array -> t                   val stable_dedup_list : Elt.t list -> Elt.t list                   val map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t) -> t                   val filter_map :                     ('a, 'b) Core_kernel.Core_set.Tree.t ->                     f:('-> Elt.t option) -> t                   val of_tree : t -> t                   val of_map_keys :                     (Elt.t, 'a, comparator_witness)                     Core_kernel.Core_set_intf.Map.t -> t                   val gen :                     Elt.t Core_kernel.Quickcheck.Generator.t ->                     t Core_kernel.Quickcheck.Generator.t                 end               type t = (Elt.t, comparator_witness) Core_kernel.Core_set.t               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               val compare : t -> t -> int               val length : t -> int               val is_empty : t -> bool               val iter : t -> f:(Elt.t -> unit) -> unit               val fold :                 t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum               val exists : t -> f:(Elt.t -> bool) -> bool               val for_all : t -> f:(Elt.t -> bool) -> bool               val count : t -> f:(Elt.t -> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 t -> f:(Elt.t -> 'sum) -> 'sum               val find : t -> f:(Elt.t -> bool) -> Elt.t option               val find_map : t -> f:(Elt.t -> 'a option) -> 'a option               val to_list : t -> Elt.t list               val to_array : t -> Elt.t array               val invariants : t -> bool               val mem : t -> Elt.t -> bool               val add : t -> Elt.t -> t               val remove : t -> Elt.t -> t               val union : t -> t -> t               val inter : t -> t -> t               val diff : t -> t -> t               val symmetric_diff :                 t ->                 t ->                 (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t               val compare_direct : t -> t -> int               val equal : t -> t -> bool               val subset : t -> t -> bool               val fold_until :                 t ->                 init:'->                 f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) -> 'b               val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b               val iter2 :                 t ->                 t ->                 f:([ `Both of Elt.t * Elt.t                    | `Left of Elt.t                    | `Right of Elt.t ] -> unit) ->                 unit               val filter : t -> f:(Elt.t -> bool) -> t               val partition_tf : t -> f:(Elt.t -> bool) -> t * t               val elements : t -> Elt.t list               val min_elt : t -> Elt.t option               val min_elt_exn : t -> Elt.t               val max_elt : t -> Elt.t option               val max_elt_exn : t -> Elt.t               val choose : t -> Elt.t option               val choose_exn : t -> Elt.t               val split : t -> Elt.t -> t * Elt.t option * t               val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list               val find_exn : t -> f:(Elt.t -> bool) -> Elt.t               val find_index : t -> int -> Elt.t option               val remove_index : t -> int -> t               val to_tree : t -> Tree.t               val to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t               val merge_to_sequence :                 ?order:[ `Decreasing | `Increasing ] ->                 ?greater_or_equal_to:Elt.t ->                 ?less_or_equal_to:Elt.t ->                 t ->                 t ->                 Elt.t Core_kernel.Core_set_intf.Merge_to_sequence_element.t                 Core_kernel.Sequence.t               val to_map :                 t ->                 f:(Elt.t -> 'data) ->                 (Elt.t, 'data, comparator_witness)                 Core_kernel.Core_set_intf.Map.t               val obs :                 Elt.t Core_kernel.Quickcheck.obs ->                 t Core_kernel.Quickcheck.obs               val shrinker :                 Elt.t Core_kernel.Quickcheck.shr ->                 t Core_kernel.Quickcheck.shr               val empty : t               val singleton : Elt.t -> t               val union_list : t list -> t               val of_list : Elt.t list -> t               val of_array : Elt.t array -> t               val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t               val of_sorted_array_unchecked : Elt.t array -> t               val stable_dedup_list : Elt.t list -> Elt.t list               val map :                 ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t               val filter_map :                 ('a, 'b) Core_kernel.Core_set.t ->                 f:('-> Elt.t option) -> t               val of_tree : Tree.t -> t               val of_map_keys :                 (Elt.t, 'a, comparator_witness)                 Core_kernel.Core_set_intf.Map.t -> t               val gen :                 Elt.t Core_kernel.Quickcheck.Generator.t ->                 t Core_kernel.Quickcheck.Generator.t               val bin_size_t : t Bin_prot.Size.sizer               val bin_write_t : t Bin_prot.Write.writer               val bin_read_t : t Bin_prot.Read.reader               val __bin_read_t__ : (int -> t) Bin_prot.Read.reader               val bin_writer_t : t Bin_prot.Type_class.writer               val bin_reader_t : t Bin_prot.Type_class.reader               val bin_t : t Bin_prot.Type_class.t             end           val hash : t -> int           val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t           module Table :             sig               type key = t               type ('a, 'b) hashtbl =                   ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t               type 'b t = (key, 'b) hashtbl               val t_of_sexp :                 (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t               type ('a, 'b) t_ = 'b t               type 'a key_ = key               val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t               val invariant :                 'Core_kernel.Invariant_intf.inv ->                 'a t Core_kernel.Invariant_intf.inv               val create :                 (key, 'b, unit -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist :                 (key, 'b,                  (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_report_all_dups :                 (key, 'b,                  (key * 'b) list ->                  [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_or_error :                 (key, 'b, (key * 'b) list -> 'b t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_exn :                 (key, 'b, (key * 'b) list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val of_alist_multi :                 (key, 'b list, (key * 'b) list -> 'b list t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_mapped :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_or_error :                 (key, 'r,                  get_key:('-> key) ->                  'r list -> 'r t Core_kernel.Or_error.t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val create_with_key_exn :                 (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val group :                 (key, 'b,                  get_key:('-> key) ->                  get_data:('-> 'b) ->                  combine:('-> '-> 'b) -> 'r list -> 'b t)                 Core_kernel.Core_hashtbl_intf.create_options_without_hashable               val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t               val clear : 'a t -> unit               val copy : 'b t -> 'b t               val fold :                 'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c               val iter_vals : 'b t -> f:('-> unit) -> unit               val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit               val iter_keys : 'a t -> f:(key -> unit) -> unit               val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit               val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool               val exists : 'b t -> f:('-> bool) -> bool               val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool               val for_all : 'b t -> f:('-> bool) -> bool               val counti : 'b t -> f:(key:key -> data:'-> bool) -> int               val count : 'b t -> f:('-> bool) -> int               val length : 'a t -> int               val is_empty : 'a t -> bool               val mem : 'a t -> key -> bool               val remove : 'a t -> key -> unit               val replace : 'b t -> key:key -> data:'-> unit               val set : 'b t -> key:key -> data:'-> unit               val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]               val add_or_error :                 'b t -> key:key -> data:'-> unit Core_kernel.Or_error.t               val add_exn : 'b t -> key:key -> data:'-> unit               val change : 'b t -> key -> f:('b option -> 'b option) -> unit               val update : 'b t -> key -> f:('b option -> 'b) -> unit               val add_multi : 'b list t -> key:key -> data:'-> unit               val remove_multi : 'a list t -> key -> unit               val map :                 ('c, 'b t -> f:('-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_map :                 ('c, 'b t -> f:('-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter_mapi :                 ('c, 'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               val filter : 'b t -> f:('-> bool) -> 'b t               val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t               val partition_map :                 ('c,                  ('d,                   'b t ->                   f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_mapi :                 ('c,                  ('d,                   'b t ->                   f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                   'c t * 'd t)                  Core_kernel.Core_hashtbl_intf.no_map_options)                 Core_kernel.Core_hashtbl_intf.no_map_options               val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t               val partitioni_tf :                 'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t               val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b               val find : 'b t -> key -> 'b option               val find_exn : 'b t -> key -> 'b               val find_and_call :                 'b t ->                 key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c               val find_and_remove : 'b t -> key -> 'b option               val merge :                 ('c,                  'a t ->                  'b t ->                  f:(key:key ->                     [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                     'c option) ->                  'c t)                 Core_kernel.Core_hashtbl_intf.no_map_options               type 'a merge_into_action = Remove | Set_to of 'a               val merge_into :                 src:'a t ->                 dst:'b t ->                 f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                 unit               val keys : 'a t -> key list               val data : 'b t -> 'b list               val filter_inplace : 'b t -> f:('-> bool) -> unit               val filteri_inplace :                 'b t -> f:(key:key -> data:'-> bool) -> unit               val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit               val map_inplace : 'b t -> f:('-> 'b) -> unit               val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit               val filter_mapi_inplace :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val replace_all : 'b t -> f:('-> 'b) -> unit               val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit               val filter_replace_all : 'b t -> f:('-> 'b option) -> unit               val filter_replace_alli :                 'b t -> f:(key:key -> data:'-> 'b option) -> unit               val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool               val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool               val to_alist : 'b t -> (key * 'b) list               val validate :                 name:(key -> string) ->                 'Core_kernel.Validate.check ->                 'b t Core_kernel.Validate.check               val incr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit               val decr :                 ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit               val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1               val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1               val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1               val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1               val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer               val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader               val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t             end           module Hash_set :             sig               type elt = t               type 'a hash_set = 'Core_kernel.Hash_set.t               type t = elt hash_set               val t_of_sexp : Sexplib.Sexp.t -> t               val sexp_of_t : t -> Sexplib.Sexp.t               type 'a t_ = t               type 'a elt_ = elt               val create :                 ('a, unit -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable               val of_list :                 ('a, elt list -> t)                 Core_kernel.Hash_set_intf.create_options_without_hashable               val bin_size_t : t Bin_prot.Size.sizer               val bin_write_t : t Bin_prot.Write.writer               val bin_read_t : t Bin_prot.Read.reader               val __bin_read_t__ : (int -> t) Bin_prot.Read.reader               val bin_writer_t : t Bin_prot.Type_class.writer               val bin_reader_t : t Bin_prot.Type_class.reader               val bin_t : t Bin_prot.Type_class.t             end           module Hash_queue :             sig               module Key :                 sig                   type t = Hash_set.elt                   val t_of_sexp : Sexplib.Sexp.t -> t                   val sexp_of_t : t -> Sexplib.Sexp.t                   val compare : t -> t -> int                   val hash : t -> int                 end               type 'a t               val sexp_of_t :                 ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t               val length : 'a t -> int               val is_empty : 'a t -> bool               val iter : 'a t -> f:('-> unit) -> unit               val fold :                 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum               val exists : 'a t -> f:('-> bool) -> bool               val for_all : 'a t -> f:('-> bool) -> bool               val count : 'a t -> f:('-> bool) -> int               val sum :                 (module Core_kernel.Commutative_group.S with type t = 'sum) ->                 'a t -> f:('-> 'sum) -> 'sum               val find : 'a t -> f:('-> bool) -> 'a option               val find_map : 'a t -> f:('-> 'b option) -> 'b option               val to_list : 'a t -> 'a list               val to_array : 'a t -> 'a array               val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option               val invariant : 'a t -> unit               val create : ?growth_allowed:bool -> ?size:int -> unit -> 'a t               val clear : 'a t -> unit               val mem : 'a t -> Key.t -> bool               val lookup : 'a t -> Key.t -> 'a option               val lookup_exn : 'a t -> Key.t -> 'a               val enqueue :                 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]               val enqueue_exn : 'a t -> Key.t -> '-> unit               val first : 'a t -> 'a option               val first_with_key : 'a t -> (Key.t * 'a) option               val keys : 'a t -> Key.t list               val dequeue : 'a t -> 'a option               val dequeue_exn : 'a t -> 'a               val dequeue_with_key : 'a t -> (Key.t * 'a) option               val dequeue_with_key_exn : 'a t -> Key.t * 'a               val dequeue_all : 'a t -> f:('-> unit) -> unit               val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]               val remove_exn : 'a t -> Key.t -> unit               val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]               val replace_exn : 'a t -> Key.t -> '-> unit               val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit               val foldi :                 'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b             end           type info = string * [ `Ver of string ] * string option           val version : string           val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int           val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t           val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes           val blit_to_bytes :             ?ver:string ->             ?fmt:string -> Regular.Std.bytes -> t -> int -> unit           val of_bigstring :             ?ver:string -> ?fmt:string -> Core_kernel.Std.bigstring -> t           val to_bigstring :             ?ver:string -> ?fmt:string -> t -> Core_kernel.Std.bigstring           val blit_to_bigstring :             ?ver:string ->             ?fmt:string -> Core_kernel.Std.bigstring -> t -> int -> unit           module Io :             sig               val read : ?ver:string -> ?fmt:string -> string -> t               val load :                 ?ver:string -> ?fmt:string -> Core_kernel.Std.in_channel -> t               val load_all :                 ?ver:string ->                 ?fmt:string ->                 ?rev:bool -> Core_kernel.Std.in_channel -> t list               val scan :                 ?ver:string ->                 ?fmt:string -> Core_kernel.Std.in_channel -> unit -> t option               val write : ?ver:string -> ?fmt:string -> string -> t -> unit               val save :                 ?ver:string ->                 ?fmt:string -> Core_kernel.Std.out_channel -> t -> unit               val save_all :                 ?ver:string ->                 ?fmt:string -> Core_kernel.Std.out_channel -> t list -> unit               val dump :                 ?ver:string ->                 ?fmt:string ->                 Core_kernel.Std.out_channel -> (unit -> t option) -> unit               val show : ?ver:string -> ?fmt:string -> t -> unit               val print :                 ?ver:string -> ?fmt:string -> Format.formatter -> t -> unit             end           module Cache :             sig               val load : Regular.Std.digest -> t option               val save : Regular.Std.digest -> t -> unit             end           val add_reader :             ?desc:string ->             ver:string -> string -> t Regular.Std.reader -> unit           val add_writer :             ?desc:string ->             ver:string -> string -> t Regular.Std.writer -> unit           val available_readers : unit -> info list           val default_reader : unit -> info           val set_default_reader : ?ver:string -> string -> unit           val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a           val available_writers : unit -> info list           val default_writer : unit -> info           val set_default_writer : ?ver:string -> string -> unit           val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a           val default_printer : unit -> info option           val set_default_printer : ?ver:string -> string -> unit           val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a           val find_reader :             ?ver:string -> string -> t Regular.Std.reader option           val find_writer :             ?ver:string -> string -> t Regular.Std.writer option         end       module type Predicate =         sig           type edge           type node           val edge : Graphlib.Std.Predicate.edge -> bool           val node : Graphlib.Std.Predicate.node -> bool         end       module type Isomorphism =         sig           type s           type t           val forward :             Graphlib.Std.Isomorphism.s -> Graphlib.Std.Isomorphism.t           val backward :             Graphlib.Std.Isomorphism.t -> Graphlib.Std.Isomorphism.s         end       class type ['n, 'e, 's] dfs_visitor =         object           method enter_edge : Graphlib.Std.edge_kind -> '-> '-> 's           method enter_node : int -> '-> '-> 's           method leave_edge : Graphlib.Std.edge_kind -> '-> '-> 's           method leave_node : int -> '-> '-> 's           method start_tree : '-> '-> 's         end       type node_attr = Graph.Graphviz.DotAttributes.vertex       type edge_attr = Graph.Graphviz.DotAttributes.edge       type graph_attr = Graph.Graphviz.DotAttributes.graph       type ('n, 'a) labeled = { node : 'n; node_label : 'a; }       module Graphlib :         sig           module Make :             functor               (Node : Regular.Std.Opaque.S) (Edge : Core_kernel.Std.T->               sig                 type t                 type node = Node.t                 type edge                 module Node :                   sig                     type t = node                     type graph = t                     type label = t                     type edge = edge                     val create : label -> label                     val label : label -> label                     val mem : label -> graph -> bool                     val succs : label -> graph -> label Regular.Std.seq                     val preds : label -> graph -> label Regular.Std.seq                     val inputs : label -> graph -> edge Regular.Std.seq                     val outputs : label -> graph -> edge Regular.Std.seq                     val degree : ?dir:[ `In | `Out ] -> label -> graph -> int                     val insert : label -> graph -> graph                     val update : label -> label -> graph -> graph                     val remove : label -> graph -> graph                     val has_edge : label -> label -> graph -> bool                     val edge : label -> label -> graph -> edge option                     val ( >= ) : label -> label -> bool                     val ( <= ) : label -> label -> bool                     val ( = ) : label -> label -> bool                     val ( > ) : label -> label -> bool                     val ( < ) : label -> label -> bool                     val ( <> ) : label -> label -> bool                     val equal : label -> label -> bool                     val min : label -> label -> label                     val max : label -> label -> label                     val ascending : label -> label -> int                     val descending : label -> label -> int                     val between : label -> low:label -> high:label -> bool                     val clamp_exn : label -> min:label -> max:label -> label                     val clamp :                       label ->                       min:label -> max:label -> label Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : label -> label -> bool                         val ( <= ) : label -> label -> bool                         val ( = ) : label -> label -> bool                         val ( > ) : label -> label -> bool                         val ( < ) : label -> label -> bool                         val ( <> ) : label -> label -> bool                         val equal : label -> label -> bool                         val compare : label -> label -> int                         val min : label -> label -> label                         val max : label -> label -> label                       end                     type comparator_witness                     val comparator :                       (label, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:label Core_kernel.Maybe_bound.t ->                       label Core_kernel.Validate.check                     val validate_ubound :                       max:label Core_kernel.Maybe_bound.t ->                       label Core_kernel.Validate.check                     val validate_bound :                       min:label Core_kernel.Maybe_bound.t ->                       max:label Core_kernel.Maybe_bound.t ->                       label Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = label                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (label, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : label -> '-> 'a t                             val of_alist :                               (label * 'a) list ->                               [ `Duplicate_key of label | `Ok of 'a t ]                             val of_alist_or_error :                               (label * 'a) list ->                               'a t Core_kernel.Or_error.t                             val of_alist_exn : (label * 'a) list -> 'a t                             val of_alist_multi :                               (label * 'a) list -> 'a list t                             val of_alist_fold :                               (label * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (label * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (label * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (label * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               label Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:label -> data:'-> 'a t                             val add_multi :                               'a list t -> key:label -> data:'-> 'a list t                             val remove_multi :                               'a list t -> label -> 'a list t                             val change :                               'a t ->                               label -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> label -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> label -> 'a option                             val find_exn : 'a t -> label -> 'a                             val remove : 'a t -> label -> 'a t                             val mem : 'a t -> label -> bool                             val iter :                               'a t ->                               f:(key:label -> data:'-> unit) -> unit                             val iteri :                               'a t ->                               f:(key:label -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(label -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:label ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:label -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:label -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:label -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:label ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t ->                               f:(key:label -> data:'-> bool) -> 'a t                             val filteri :                               'a t ->                               f:(key:label -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(label -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:label -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:label ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:label -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> label list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (label * 'a) list                             val validate :                               name:(label -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:label ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (label, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (label * 'a) option                             val min_elt_exn : 'a t -> label * 'a                             val max_elt : 'a t -> (label * 'a) option                             val max_elt_exn : 'a t -> label * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t ->                               f:(key:label -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t ->                               f:(key:label -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:label -> data:'-> bool) -> int                             val split :                               'a t ->                               label -> 'a t * (label * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:label ->                               max:label ->                               init:'->                               f:(key:label -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:label -> max:label -> (label * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> label -> (label * 'a) option                             val nth : 'a t -> int -> (label * 'a) option                             val rank : 'a t -> label -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:label ->                               ?keys_less_or_equal_to:label ->                               'a t -> (label * 'a) Core_kernel.Sequence.t                             val obs :                               label Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               label Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (label, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : label -> '-> 'a t                         val of_alist :                           (label * 'a) list ->                           [ `Duplicate_key of label | `Ok of 'a t ]                         val of_alist_or_error :                           (label * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (label * 'a) list -> 'a t                         val of_alist_multi : (label * 'a) list -> 'a list t                         val of_alist_fold :                           (label * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (label * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (label * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (label * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           label Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:label -> data:'-> 'a t                         val add_multi :                           'a list t -> key:label -> data:'-> 'a list t                         val remove_multi : 'a list t -> label -> 'a list t                         val change :                           'a t -> label -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> label -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> label -> 'a option                         val find_exn : 'a t -> label -> 'a                         val remove : 'a t -> label -> 'a t                         val mem : 'a t -> label -> bool                         val iter :                           'a t -> f:(key:label -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:label -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(label -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:label ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:label -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:label -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:label -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:label ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:label -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:label -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(label -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:label -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:label ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:label -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> label list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (label * 'a) list                         val validate :                           name:(label -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:label ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (label, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (label * 'a) option                         val min_elt_exn : 'a t -> label * 'a                         val max_elt : 'a t -> (label * 'a) option                         val max_elt_exn : 'a t -> label * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:label -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:label -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:label -> data:'-> bool) -> int                         val split :                           'a t -> label -> 'a t * (label * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:label ->                           max:label ->                           init:'->                           f:(key:label -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:label -> max:label -> (label * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> label -> (label * 'a) option                         val nth : 'a t -> int -> (label * 'a) option                         val rank : 'a t -> label -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:label ->                           ?keys_less_or_equal_to:label ->                           'a t -> (label * 'a) Core_kernel.Sequence.t                         val obs :                           label Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           label Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = label                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (label, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(label -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> label -> 'accum) -> 'accum                             val exists : t -> f:(label -> bool) -> bool                             val for_all : t -> f:(label -> bool) -> bool                             val count : t -> f:(label -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(label -> 'sum) -> 'sum                             val find : t -> f:(label -> bool) -> label option                             val find_map :                               t -> f:(label -> 'a option) -> 'a option                             val to_list : t -> label list                             val to_array : t -> label array                             val invariants : t -> bool                             val mem : t -> label -> bool                             val add : t -> label -> t                             val remove : t -> label -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (label, label) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  label -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(label -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of label * label                                  | `Left of label                                  | `Right of label ] -> unit) ->                               unit                             val filter : t -> f:(label -> bool) -> t                             val partition_tf :                               t -> f:(label -> bool) -> t * t                             val elements : t -> label list                             val min_elt : t -> label option                             val min_elt_exn : t -> label                             val max_elt : t -> label option                             val max_elt_exn : t -> label                             val choose : t -> label option                             val choose_exn : t -> label                             val split : t -> label -> t * label option * t                             val group_by :                               t -> equiv:(label -> label -> bool) -> t list                             val find_exn : t -> f:(label -> bool) -> label                             val find_index : t -> int -> label option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:label ->                               ?less_or_equal_to:label ->                               t -> label Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:label ->                               ?less_or_equal_to:label ->                               t ->                               t ->                               label                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(label -> 'data) ->                               (label, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               label Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               label Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : label -> t                             val union_list : t list -> t                             val of_list : label list -> t                             val of_array : label array -> t                             val of_sorted_array :                               label array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : label array -> t                             val stable_dedup_list : label list -> label list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> label) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> label option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (label, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               label Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (label, comparator_witness)                             Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(label -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> label -> 'accum) -> 'accum                         val exists : t -> f:(label -> bool) -> bool                         val for_all : t -> f:(label -> bool) -> bool                         val count : t -> f:(label -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(label -> 'sum) -> 'sum                         val find : t -> f:(label -> bool) -> label option                         val find_map :                           t -> f:(label -> 'a option) -> 'a option                         val to_list : t -> label list                         val to_array : t -> label array                         val invariants : t -> bool                         val mem : t -> label -> bool                         val add : t -> label -> t                         val remove : t -> label -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (label, label) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> label -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(label -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of label * label                              | `Left of label                              | `Right of label ] -> unit) ->                           unit                         val filter : t -> f:(label -> bool) -> t                         val partition_tf : t -> f:(label -> bool) -> t * t                         val elements : t -> label list                         val min_elt : t -> label option                         val min_elt_exn : t -> label                         val max_elt : t -> label option                         val max_elt_exn : t -> label                         val choose : t -> label option                         val choose_exn : t -> label                         val split : t -> label -> t * label option * t                         val group_by :                           t -> equiv:(label -> label -> bool) -> t list                         val find_exn : t -> f:(label -> bool) -> label                         val find_index : t -> int -> label option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:label ->                           ?less_or_equal_to:label ->                           t -> label Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:label ->                           ?less_or_equal_to:label ->                           t ->                           t ->                           label                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(label -> 'data) ->                           (label, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           label Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           label Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : label -> t                         val union_list : t list -> t                         val of_list : label list -> t                         val of_array : label array -> t                         val of_sorted_array :                           label array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : label array -> t                         val stable_dedup_list : label list -> label list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> label) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> label option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (label, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           label Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : label -> int                     val compare : label -> label -> int                     val hashable :                       label Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = label                         type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = label                         type 'a hash_set = 'Equiv.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = label                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> label -> bool                         val lookup : 'a t -> label -> 'a option                         val lookup_exn : 'a t -> label -> 'a                         val enqueue :                           'a t ->                           label -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> label -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (label * 'a) option                         val keys : 'a t -> label list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (label * 'a) option                         val dequeue_with_key_exn : 'a t -> label * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> label -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> label -> unit                         val replace :                           'a t -> label -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> label -> '-> unit                         val iteri :                           'a t -> f:(key:label -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:label -> data:'-> 'b) -> 'b                       end                   end                 module Edge :                   sig                     type t = edge                     type node = Node.t                     type graph = Node.graph                     type label = Edge.t                     val create : node -> node -> label -> t                     val label : t -> label                     val src : t -> node                     val dst : t -> node                     val mem : t -> graph -> bool                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = edge                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (edge, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : edge -> '-> 'a t                             val of_alist :                               (edge * 'a) list ->                               [ `Duplicate_key of edge | `Ok of 'a t ]                             val of_alist_or_error :                               (edge * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (edge * 'a) list -> 'a t                             val of_alist_multi :                               (edge * 'a) list -> 'a list t                             val of_alist_fold :                               (edge * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (edge * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (edge * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:edge -> data:'-> 'a t                             val add_multi :                               'a list t -> key:edge -> data:'-> 'a list t                             val remove_multi : 'a list t -> edge -> 'a list t                             val change :                               'a t ->                               edge -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> edge -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> edge -> 'a option                             val find_exn : 'a t -> edge -> 'a                             val remove : 'a t -> edge -> 'a t                             val mem : 'a t -> edge -> bool                             val iter :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(edge -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(edge -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:edge -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:edge ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:edge -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> edge list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (edge * 'a) list                             val validate :                               name:(edge -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:edge ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (edge, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (edge * 'a) option                             val min_elt_exn : 'a t -> edge * 'a                             val max_elt : 'a t -> (edge * 'a) option                             val max_elt_exn : 'a t -> edge * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:edge -> data:'-> bool) -> int                             val split :                               'a t ->                               edge -> 'a t * (edge * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:edge ->                               max:edge ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:edge -> max:edge -> (edge * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> edge -> (edge * 'a) option                             val nth : 'a t -> int -> (edge * 'a) option                             val rank : 'a t -> edge -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:edge ->                               ?keys_less_or_equal_to:edge ->                               'a t -> (edge * 'a) Core_kernel.Sequence.t                             val obs :                               edge Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               edge Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (edge, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : edge -> '-> 'a t                         val of_alist :                           (edge * 'a) list ->                           [ `Duplicate_key of edge | `Ok of 'a t ]                         val of_alist_or_error :                           (edge * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (edge * 'a) list -> 'a t                         val of_alist_multi : (edge * 'a) list -> 'a list t                         val of_alist_fold :                           (edge * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (edge * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (edge * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:edge -> data:'-> 'a t                         val add_multi :                           'a list t -> key:edge -> data:'-> 'a list t                         val remove_multi : 'a list t -> edge -> 'a list t                         val change :                           'a t -> edge -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> edge -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> edge -> 'a option                         val find_exn : 'a t -> edge -> 'a                         val remove : 'a t -> edge -> 'a t                         val mem : 'a t -> edge -> bool                         val iter :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(edge -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:edge -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:edge ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:edge -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> edge list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (edge * 'a) list                         val validate :                           name:(edge -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:edge ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (edge, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (edge * 'a) option                         val min_elt_exn : 'a t -> edge * 'a                         val max_elt : 'a t -> (edge * 'a) option                         val max_elt_exn : 'a t -> edge * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:edge -> data:'-> bool) -> int                         val split :                           'a t -> edge -> 'a t * (edge * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:edge ->                           max:edge ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:edge -> max:edge -> (edge * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> edge -> (edge * 'a) option                         val nth : 'a t -> int -> (edge * 'a) option                         val rank : 'a t -> edge -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:edge ->                           ?keys_less_or_equal_to:edge ->                           'a t -> (edge * 'a) Core_kernel.Sequence.t                         val obs :                           edge Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           edge Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (edge, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(edge -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> edge -> 'accum) -> 'accum                             val exists : t -> f:(edge -> bool) -> bool                             val for_all : t -> f:(edge -> bool) -> bool                             val count : t -> f:(edge -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(edge -> 'sum) -> 'sum                             val find : t -> f:(edge -> bool) -> edge option                             val find_map :                               t -> f:(edge -> 'a option) -> 'a option                             val to_list : t -> edge list                             val to_array : t -> edge array                             val invariants : t -> bool                             val mem : t -> edge -> bool                             val add : t -> edge -> t                             val remove : t -> edge -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (edge, edge) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  edge -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(edge -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of edge * edge                                  | `Left of edge                                  | `Right of edge ] -> unit) ->                               unit                             val filter : t -> f:(edge -> bool) -> t                             val partition_tf : t -> f:(edge -> bool) -> t * t                             val elements : t -> edge list                             val min_elt : t -> edge option                             val min_elt_exn : t -> edge                             val max_elt : t -> edge option                             val max_elt_exn : t -> edge                             val choose : t -> edge option                             val choose_exn : t -> edge                             val split : t -> edge -> t * edge option * t                             val group_by :                               t -> equiv:(edge -> edge -> bool) -> t list                             val find_exn : t -> f:(edge -> bool) -> edge                             val find_index : t -> int -> edge option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t -> edge Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t ->                               t ->                               edge                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(edge -> 'data) ->                               (edge, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               edge Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               edge Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : edge -> t                             val union_list : t list -> t                             val of_list : edge list -> t                             val of_array : edge array -> t                             val of_sorted_array :                               edge array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : edge array -> t                             val stable_dedup_list : edge list -> edge list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (edge, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (edge, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(edge -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> edge -> 'accum) -> 'accum                         val exists : t -> f:(edge -> bool) -> bool                         val for_all : t -> f:(edge -> bool) -> bool                         val count : t -> f:(edge -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(edge -> 'sum) -> 'sum                         val find : t -> f:(edge -> bool) -> edge option                         val find_map :                           t -> f:(edge -> 'a option) -> 'a option                         val to_list : t -> edge list                         val to_array : t -> edge array                         val invariants : t -> bool                         val mem : t -> edge -> bool                         val add : t -> edge -> t                         val remove : t -> edge -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (edge, edge) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> edge -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(edge -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of edge * edge                              | `Left of edge                              | `Right of edge ] -> unit) ->                           unit                         val filter : t -> f:(edge -> bool) -> t                         val partition_tf : t -> f:(edge -> bool) -> t * t                         val elements : t -> edge list                         val min_elt : t -> edge option                         val min_elt_exn : t -> edge                         val max_elt : t -> edge option                         val max_elt_exn : t -> edge                         val choose : t -> edge option                         val choose_exn : t -> edge                         val split : t -> edge -> t * edge option * t                         val group_by :                           t -> equiv:(edge -> edge -> bool) -> t list                         val find_exn : t -> f:(edge -> bool) -> edge                         val find_index : t -> int -> edge option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t -> edge Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t ->                           t ->                           edge                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(edge -> 'data) ->                           (edge, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           edge Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           edge Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : edge -> t                         val union_list : t list -> t                         val of_list : edge list -> t                         val of_array : edge array -> t                         val of_sorted_array :                           edge array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : edge array -> t                         val stable_dedup_list : edge list -> edge list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (edge, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Node.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> edge -> bool                         val lookup : 'a t -> edge -> 'a option                         val lookup_exn : 'a t -> edge -> 'a                         val enqueue :                           'a t ->                           edge -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> edge -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (edge * 'a) option                         val keys : 'a t -> edge list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (edge * 'a) option                         val dequeue_with_key_exn : 'a t -> edge * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> edge -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> edge -> unit                         val replace :                           'a t -> edge -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> edge -> '-> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:edge -> data:'-> 'b) -> 'b                       end                   end                 val empty : t                 val nodes : t -> node Regular.Std.seq                 val edges : t -> edge Regular.Std.seq                 val is_directed : bool                 val number_of_edges : t -> int                 val number_of_nodes : t -> int                 val ( >= ) : t -> t -> bool                 val ( <= ) : t -> t -> bool                 val ( = ) : t -> t -> bool                 val ( > ) : t -> t -> bool                 val ( < ) : t -> t -> bool                 val ( <> ) : t -> t -> bool                 val equal : t -> t -> bool                 val min : t -> t -> t                 val max : t -> t -> t                 val ascending : t -> t -> int                 val descending : t -> t -> int                 val between : t -> low:t -> high:t -> bool                 val clamp_exn : t -> min:t -> max:t -> t                 val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t                 module Replace_polymorphic_compare :                   sig                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val compare : t -> t -> int                     val min : t -> t -> t                     val max : t -> t -> t                   end                 type comparator_witness                 val comparator :                   (t, comparator_witness) Core_kernel.Comparator.comparator                 val validate_lbound :                   min:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_ubound :                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_bound :                   min:t Core_kernel.Maybe_bound.t ->                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 module Map :                   sig                     module Key :                       sig                         type t = Edge.graph                         type comparator_witness = comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type 'a t =                             (Key.t, 'a, comparator_witness)                             Core_kernel.Core_map.Tree.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val empty : 'a t                         val singleton : Key.t -> '-> 'a t                         val of_alist :                           (Key.t * 'a) list ->                           [ `Duplicate_key of Key.t | `Ok of 'a t ]                         val of_alist_or_error :                           (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (Key.t * 'a) list -> 'a t                         val of_alist_multi : (Key.t * 'a) list -> 'a list t                         val of_alist_fold :                           (Key.t * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (Key.t * 'a) array -> 'a t                         val of_tree : 'a t -> 'a t                         val gen :                           Key.t Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:Key.t -> data:'-> 'a t                         val add_multi :                           'a list t -> key:Key.t -> data:'-> 'a list t                         val remove_multi : 'a list t -> Key.t -> 'a list t                         val change :                           'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> Key.t -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> Key.t -> 'a option                         val find_exn : 'a t -> Key.t -> 'a                         val remove : 'a t -> Key.t -> 'a t                         val mem : 'a t -> Key.t -> bool                         val iter :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:Key.t -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:Key.t ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> Key.t list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (Key.t * 'a) list                         val validate :                           name:(Key.t -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (Key.t, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (Key.t * 'a) option                         val min_elt_exn : 'a t -> Key.t * 'a                         val max_elt : 'a t -> (Key.t * 'a) option                         val max_elt_exn : 'a t -> Key.t * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:Key.t -> data:'-> bool) -> int                         val split :                           'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:Key.t ->                           max:Key.t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> Key.t -> (Key.t * 'a) option                         val nth : 'a t -> int -> (Key.t * 'a) option                         val rank : 'a t -> Key.t -> int option                         val to_tree : 'a t -> 'a t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:Key.t ->                           ?keys_less_or_equal_to:Key.t ->                           'a t -> (Key.t * 'a) Core_kernel.Sequence.t                         val obs :                           Key.t Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           Key.t Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     type 'a t =                         (Key.t, 'a, comparator_witness)                         Core_kernel.Core_map.t                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val compare : ('-> '-> int) -> 'a t -> 'a t -> int                     val empty : 'a t                     val singleton : Key.t -> '-> 'a t                     val of_alist :                       (Key.t * 'a) list ->                       [ `Duplicate_key of Key.t | `Ok of 'a t ]                     val of_alist_or_error :                       (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                     val of_alist_exn : (Key.t * 'a) list -> 'a t                     val of_alist_multi : (Key.t * 'a) list -> 'a list t                     val of_alist_fold :                       (Key.t * 'a) list ->                       init:'-> f:('-> '-> 'b) -> 'b t                     val of_alist_reduce :                       (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                     val of_sorted_array :                       (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                     val of_sorted_array_unchecked :                       (Key.t * 'a) array -> 'a t                     val of_tree : 'Tree.t -> 'a t                     val gen :                       Key.t Core_kernel.Quickcheck.Generator.t ->                       'Core_kernel.Quickcheck.Generator.t ->                       'a t Core_kernel.Quickcheck.Generator.t                     val invariants : 'a t -> bool                     val is_empty : 'a t -> bool                     val length : 'a t -> int                     val add : 'a t -> key:Key.t -> data:'-> 'a t                     val add_multi :                       'a list t -> key:Key.t -> data:'-> 'a list t                     val remove_multi : 'a list t -> Key.t -> 'a list t                     val change :                       'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                     val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                     val find : 'a t -> Key.t -> 'a option                     val find_exn : 'a t -> Key.t -> 'a                     val remove : 'a t -> Key.t -> 'a t                     val mem : 'a t -> Key.t -> bool                     val iter :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                     val iter2 :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          unit) ->                       unit                     val map : 'a t -> f:('-> 'b) -> 'b t                     val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                     val fold :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold_right :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold2 :                       'a t ->                       'b t ->                       init:'->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          '-> 'c) ->                       'c                     val filter :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filteri :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                     val filter_map : 'a t -> f:('-> 'b option) -> 'b t                     val filter_mapi :                       'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                     val partition_mapi :                       'a t ->                       f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                       'b t * 'c t                     val partition_map :                       'a t ->                       f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                     val partitioni_tf :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                     val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                     val compare_direct :                       ('-> '-> int) -> 'a t -> 'a t -> int                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                     val keys : 'a t -> Key.t list                     val data : 'a t -> 'a list                     val to_alist :                       ?key_order:[ `Decreasing | `Increasing ] ->                       'a t -> (Key.t * 'a) list                     val validate :                       name:(Key.t -> string) ->                       'Core_kernel.Validate.check ->                       'a t Core_kernel.Validate.check                     val merge :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          'c option) ->                       'c t                     val symmetric_diff :                       'a t ->                       'a t ->                       data_equal:('-> '-> bool) ->                       (Key.t, 'a)                       Core_kernel.Core_map_intf.Symmetric_diff_element.t                       Core_kernel.Sequence.t                     val min_elt : 'a t -> (Key.t * 'a) option                     val min_elt_exn : 'a t -> Key.t * 'a                     val max_elt : 'a t -> (Key.t * 'a) option                     val max_elt_exn : 'a t -> Key.t * 'a                     val for_all : 'a t -> f:('-> bool) -> bool                     val for_alli :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val exists : 'a t -> f:('-> bool) -> bool                     val existsi :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val counti :                       'a t -> f:(key:Key.t -> data:'-> bool) -> int                     val split :                       'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                     val fold_range_inclusive :                       'a t ->                       min:Key.t ->                       max:Key.t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val range_to_alist :                       'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                     val closest_key :                       'a t ->                       [ `Greater_or_equal_to                       | `Greater_than                       | `Less_or_equal_to                       | `Less_than ] -> Key.t -> (Key.t * 'a) option                     val nth : 'a t -> int -> (Key.t * 'a) option                     val rank : 'a t -> Key.t -> int option                     val to_tree : 'a t -> 'Tree.t                     val to_sequence :                       ?order:[ `Decreasing_key | `Increasing_key ] ->                       ?keys_greater_or_equal_to:Key.t ->                       ?keys_less_or_equal_to:Key.t ->                       'a t -> (Key.t * 'a) Core_kernel.Sequence.t                     val obs :                       Key.t Core_kernel.Quickcheck.Observer.t ->                       'Core_kernel.Quickcheck.Observer.t ->                       'v t Core_kernel.Quickcheck.Observer.t                     val shrinker :                       Key.t Core_kernel.Quickcheck.Shrinker.t ->                       'Core_kernel.Quickcheck.Shrinker.t ->                       'v t Core_kernel.Quickcheck.Shrinker.t                   end                 module Set :                   sig                     module Elt :                       sig                         type t = Edge.graph                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type comparator_witness = Map.Key.comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type t =                             (Elt.t, comparator_witness)                             Core_kernel.Core_set.Tree.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(Elt.t -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> Elt.t -> 'accum) -> 'accum                         val exists : t -> f:(Elt.t -> bool) -> bool                         val for_all : t -> f:(Elt.t -> bool) -> bool                         val count : t -> f:(Elt.t -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(Elt.t -> 'sum) -> 'sum                         val find : t -> f:(Elt.t -> bool) -> Elt.t option                         val find_map :                           t -> f:(Elt.t -> 'a option) -> 'a option                         val to_list : t -> Elt.t list                         val to_array : t -> Elt.t array                         val invariants : t -> bool                         val mem : t -> Elt.t -> bool                         val add : t -> Elt.t -> t                         val remove : t -> Elt.t -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (Elt.t, Elt.t) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of Elt.t * Elt.t                              | `Left of Elt.t                              | `Right of Elt.t ] -> unit) ->                           unit                         val filter : t -> f:(Elt.t -> bool) -> t                         val partition_tf : t -> f:(Elt.t -> bool) -> t * t                         val elements : t -> Elt.t list                         val min_elt : t -> Elt.t option                         val min_elt_exn : t -> Elt.t                         val max_elt : t -> Elt.t option                         val max_elt_exn : t -> Elt.t                         val choose : t -> Elt.t option                         val choose_exn : t -> Elt.t                         val split : t -> Elt.t -> t * Elt.t option * t                         val group_by :                           t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                         val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                         val find_index : t -> int -> Elt.t option                         val remove_index : t -> int -> t                         val to_tree : t -> t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t -> Elt.t Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t ->                           t ->                           Elt.t                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(Elt.t -> 'data) ->                           (Elt.t, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           Elt.t Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           Elt.t Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : Elt.t -> t                         val union_list : t list -> t                         val of_list : Elt.t list -> t                         val of_array : Elt.t array -> t                         val of_sorted_array :                           Elt.t array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : Elt.t array -> t                         val stable_dedup_list : Elt.t list -> Elt.t list                         val map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t option) -> t                         val of_tree : t -> t                         val of_map_keys :                           (Elt.t, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           Elt.t Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     type t =                         (Elt.t, comparator_witness) Core_kernel.Core_set.t                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     val compare : t -> t -> int                     val length : t -> int                     val is_empty : t -> bool                     val iter : t -> f:(Elt.t -> unit) -> unit                     val fold :                       t ->                       init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                     val exists : t -> f:(Elt.t -> bool) -> bool                     val for_all : t -> f:(Elt.t -> bool) -> bool                     val count : t -> f:(Elt.t -> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       t -> f:(Elt.t -> 'sum) -> 'sum                     val find : t -> f:(Elt.t -> bool) -> Elt.t option                     val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                     val to_list : t -> Elt.t list                     val to_array : t -> Elt.t array                     val invariants : t -> bool                     val mem : t -> Elt.t -> bool                     val add : t -> Elt.t -> t                     val remove : t -> Elt.t -> t                     val union : t -> t -> t                     val inter : t -> t -> t                     val diff : t -> t -> t                     val symmetric_diff :                       t ->                       t ->                       (Elt.t, Elt.t) Core_kernel.Either.t                       Core_kernel.Sequence.t                     val compare_direct : t -> t -> int                     val equal : t -> t -> bool                     val subset : t -> t -> bool                     val fold_until :                       t ->                       init:'->                       f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                       'b                     val fold_right :                       t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                     val iter2 :                       t ->                       t ->                       f:([ `Both of Elt.t * Elt.t                          | `Left of Elt.t                          | `Right of Elt.t ] -> unit) ->                       unit                     val filter : t -> f:(Elt.t -> bool) -> t                     val partition_tf : t -> f:(Elt.t -> bool) -> t * t                     val elements : t -> Elt.t list                     val min_elt : t -> Elt.t option                     val min_elt_exn : t -> Elt.t                     val max_elt : t -> Elt.t option                     val max_elt_exn : t -> Elt.t                     val choose : t -> Elt.t option                     val choose_exn : t -> Elt.t                     val split : t -> Elt.t -> t * Elt.t option * t                     val group_by :                       t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                     val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                     val find_index : t -> int -> Elt.t option                     val remove_index : t -> int -> t                     val to_tree : t -> Tree.t                     val to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t -> Elt.t Core_kernel.Sequence.t                     val merge_to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t ->                       t ->                       Elt.t                       Core_kernel.Core_set_intf.Merge_to_sequence_element.t                       Core_kernel.Sequence.t                     val to_map :                       t ->                       f:(Elt.t -> 'data) ->                       (Elt.t, 'data, comparator_witness)                       Core_kernel.Core_set_intf.Map.t                     val obs :                       Elt.t Core_kernel.Quickcheck.obs ->                       t Core_kernel.Quickcheck.obs                     val shrinker :                       Elt.t Core_kernel.Quickcheck.shr ->                       t Core_kernel.Quickcheck.shr                     val empty : t                     val singleton : Elt.t -> t                     val union_list : t list -> t                     val of_list : Elt.t list -> t                     val of_array : Elt.t array -> t                     val of_sorted_array :                       Elt.t array -> t Core_kernel.Or_error.t                     val of_sorted_array_unchecked : Elt.t array -> t                     val stable_dedup_list : Elt.t list -> Elt.t list                     val map :                       ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t                     val filter_map :                       ('a, 'b) Core_kernel.Core_set.t ->                       f:('-> Elt.t option) -> t                     val of_tree : Tree.t -> t                     val of_map_keys :                       (Elt.t, 'a, comparator_witness)                       Core_kernel.Core_set_intf.Map.t -> t                     val gen :                       Elt.t Core_kernel.Quickcheck.Generator.t ->                       t Core_kernel.Quickcheck.Generator.t                   end                 val hash : t -> int                 val compare : t -> t -> int                 val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                 module Table :                   sig                     type key = t                     type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl                     type 'b t = (key, 'b) hashtbl                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                     type ('a, 'b) t_ = 'b t                     type 'a key_ = key                     val hashable :                       key Core_kernel.Core_hashtbl_intf.Hashable.t                     val invariant :                       'Core_kernel.Invariant_intf.inv ->                       'a t Core_kernel.Invariant_intf.inv                     val create :                       (key, 'b, unit -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_key of key | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_report_all_dups :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_or_error :                       (key, 'b,                        (key * 'b) list -> 'b t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_exn :                       (key, 'b, (key * 'b) list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_multi :                       (key, 'b list, (key * 'b) list -> 'b list t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_mapped :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key :                       (key, 'r,                        get_key:('-> key) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'r t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_or_error :                       (key, 'r,                        get_key:('-> key) ->                        'r list -> 'r t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_exn :                       (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val group :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        combine:('-> '-> 'b) -> 'r list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                     val clear : 'a t -> unit                     val copy : 'b t -> 'b t                     val fold :                       'b t ->                       init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                     val iter_vals : 'b t -> f:('-> unit) -> unit                     val iteri :                       'b t -> f:(key:key -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(key -> unit) -> unit                     val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                     val existsi :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val exists : 'b t -> f:('-> bool) -> bool                     val for_alli :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val for_all : 'b t -> f:('-> bool) -> bool                     val counti :                       'b t -> f:(key:key -> data:'-> bool) -> int                     val count : 'b t -> f:('-> bool) -> int                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val mem : 'a t -> key -> bool                     val remove : 'a t -> key -> unit                     val replace : 'b t -> key:key -> data:'-> unit                     val set : 'b t -> key:key -> data:'-> unit                     val add :                       'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                     val add_or_error :                       'b t ->                       key:key -> data:'-> unit Core_kernel.Or_error.t                     val add_exn : 'b t -> key:key -> data:'-> unit                     val change :                       'b t -> key -> f:('b option -> 'b option) -> unit                     val update : 'b t -> key -> f:('b option -> 'b) -> unit                     val add_multi : 'b list t -> key:key -> data:'-> unit                     val remove_multi : 'a list t -> key -> unit                     val map :                       ('c, 'b t -> f:('-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val mapi :                       ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_map :                       ('c, 'b t -> f:('-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_mapi :                       ('c,                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter : 'b t -> f:('-> bool) -> 'b t                     val filteri :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t                     val partition_map :                       ('c,                        ('d,                         'b t ->                         f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_mapi :                       ('c,                        ('d,                         'b t ->                         f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                         'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                     val partitioni_tf :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                     val find_or_add :                       'b t -> key -> default:(unit -> 'b) -> 'b                     val find : 'b t -> key -> 'b option                     val find_exn : 'b t -> key -> 'b                     val find_and_call :                       'b t ->                       key ->                       if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                     val find_and_remove : 'b t -> key -> 'b option                     val merge :                       ('c,                        'a t ->                        'b t ->                        f:(key:key ->                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                           'c option) ->                        'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     type 'a merge_into_action = Remove | Set_to of 'a                     val merge_into :                       src:'a t ->                       dst:'b t ->                       f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                       unit                     val keys : 'a t -> key list                     val data : 'b t -> 'b list                     val filter_inplace : 'b t -> f:('-> bool) -> unit                     val filteri_inplace :                       'b t -> f:(key:key -> data:'-> bool) -> unit                     val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                     val map_inplace : 'b t -> f:('-> 'b) -> unit                     val mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_map_inplace :                       'b t -> f:('-> 'b option) -> unit                     val filter_mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val replace_all : 'b t -> f:('-> 'b) -> unit                     val replace_alli :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_replace_all :                       'b t -> f:('-> 'b option) -> unit                     val filter_replace_alli :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                     val similar :                       'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                     val to_alist : 'b t -> (key * 'b) list                     val validate :                       name:(key -> string) ->                       'Core_kernel.Validate.check ->                       'b t Core_kernel.Validate.check                     val incr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                     val decr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   end                 module Hash_set :                   sig                     type elt = t                     type 'a hash_set = 'Edge.Hash_set.hash_set                     type t = elt hash_set                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     type 'a t_ = t                     type 'a elt_ = elt                     val create :                       ('a, unit -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                     val of_list :                       ('a, elt list -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                   end                 module Hash_queue :                   sig                     module Key :                       sig                         type t = Hash_set.elt                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val hash : t -> int                       end                     type 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val iter : 'a t -> f:('-> unit) -> unit                     val fold :                       'a t ->                       init:'accum -> f:('accum -> '-> 'accum) -> 'accum                     val exists : 'a t -> f:('-> bool) -> bool                     val for_all : 'a t -> f:('-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       'a t -> f:('-> 'sum) -> 'sum                     val find : 'a t -> f:('-> bool) -> 'a option                     val find_map : 'a t -> f:('-> 'b option) -> 'b option                     val to_list : 'a t -> 'a list                     val to_array : 'a t -> 'a array                     val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val invariant : 'a t -> unit                     val create :                       ?growth_allowed:bool -> ?size:int -> unit -> 'a t                     val clear : 'a t -> unit                     val mem : 'a t -> Key.t -> bool                     val lookup : 'a t -> Key.t -> 'a option                     val lookup_exn : 'a t -> Key.t -> 'a                     val enqueue :                       'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]                     val enqueue_exn : 'a t -> Key.t -> '-> unit                     val first : 'a t -> 'a option                     val first_with_key : 'a t -> (Key.t * 'a) option                     val keys : 'a t -> Key.t list                     val dequeue : 'a t -> 'a option                     val dequeue_exn : 'a t -> 'a                     val dequeue_with_key : 'a t -> (Key.t * 'a) option                     val dequeue_with_key_exn : 'a t -> Key.t * 'a                     val dequeue_all : 'a t -> f:('-> unit) -> unit                     val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]                     val remove_exn : 'a t -> Key.t -> unit                     val replace :                       'a t -> Key.t -> '-> [ `No_such_key | `Ok ]                     val replace_exn : 'a t -> Key.t -> '-> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val foldi :                       'a t ->                       init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b                   end                 val to_string : t -> string                 val str : unit -> t -> string                 val pps : unit -> t -> string                 val ppo : Core_kernel.Std.out_channel -> t -> unit                 val pp_seq :                   Format.formatter -> t Core_kernel.Std.Sequence.t -> unit                 val pp : Format.formatter -> t -> unit               end           module Labeled :             functor               (Node : Regular.Std.Opaque.S) (NL : Core_kernel.Std.T) (EL : Core_kernel.Std.T->               sig                 type t                 type node = (Node.t, NL.t) labeled                 type edge                 module Node :                   sig                     type t = node                     type graph = t                     type label = (Node.t, NL.t) labeled                     type edge = edge                     val create : label -> t                     val label : t -> label                     val mem : t -> graph -> bool                     val succs : t -> graph -> t Regular.Std.seq                     val preds : t -> graph -> t Regular.Std.seq                     val inputs : t -> graph -> edge Regular.Std.seq                     val outputs : t -> graph -> edge Regular.Std.seq                     val degree : ?dir:[ `In | `Out ] -> t -> graph -> int                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val has_edge : t -> t -> graph -> bool                     val edge : t -> t -> graph -> edge option                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = node                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (node, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : node -> '-> 'a t                             val of_alist :                               (node * 'a) list ->                               [ `Duplicate_key of node | `Ok of 'a t ]                             val of_alist_or_error :                               (node * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (node * 'a) list -> 'a t                             val of_alist_multi :                               (node * 'a) list -> 'a list t                             val of_alist_fold :                               (node * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (node * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (node * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (node * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:node -> data:'-> 'a t                             val add_multi :                               'a list t -> key:node -> data:'-> 'a list t                             val remove_multi : 'a list t -> node -> 'a list t                             val change :                               'a t ->                               node -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> node -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> node -> 'a option                             val find_exn : 'a t -> node -> 'a                             val remove : 'a t -> node -> 'a t                             val mem : 'a t -> node -> bool                             val iter :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(node -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:node -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(node -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:node -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:node ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:node -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> node list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (node * 'a) list                             val validate :                               name:(node -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:node ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (node, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (node * 'a) option                             val min_elt_exn : 'a t -> node * 'a                             val max_elt : 'a t -> (node * 'a) option                             val max_elt_exn : 'a t -> node * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:node -> data:'-> bool) -> int                             val split :                               'a t ->                               node -> 'a t * (node * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:node ->                               max:node ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:node -> max:node -> (node * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> node -> (node * 'a) option                             val nth : 'a t -> int -> (node * 'a) option                             val rank : 'a t -> node -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:node ->                               ?keys_less_or_equal_to:node ->                               'a t -> (node * 'a) Core_kernel.Sequence.t                             val obs :                               node Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               node Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (node, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : node -> '-> 'a t                         val of_alist :                           (node * 'a) list ->                           [ `Duplicate_key of node | `Ok of 'a t ]                         val of_alist_or_error :                           (node * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (node * 'a) list -> 'a t                         val of_alist_multi : (node * 'a) list -> 'a list t                         val of_alist_fold :                           (node * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (node * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (node * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (node * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:node -> data:'-> 'a t                         val add_multi :                           'a list t -> key:node -> data:'-> 'a list t                         val remove_multi : 'a list t -> node -> 'a list t                         val change :                           'a t -> node -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> node -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> node -> 'a option                         val find_exn : 'a t -> node -> 'a                         val remove : 'a t -> node -> 'a t                         val mem : 'a t -> node -> bool                         val iter :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(node -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:node -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(node -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:node -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:node ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:node -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> node list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (node * 'a) list                         val validate :                           name:(node -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:node ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (node, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (node * 'a) option                         val min_elt_exn : 'a t -> node * 'a                         val max_elt : 'a t -> (node * 'a) option                         val max_elt_exn : 'a t -> node * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:node -> data:'-> bool) -> int                         val split :                           'a t -> node -> 'a t * (node * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:node ->                           max:node ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:node -> max:node -> (node * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> node -> (node * 'a) option                         val nth : 'a t -> int -> (node * 'a) option                         val rank : 'a t -> node -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:node ->                           ?keys_less_or_equal_to:node ->                           'a t -> (node * 'a) Core_kernel.Sequence.t                         val obs :                           node Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           node Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (node, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(node -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> node -> 'accum) -> 'accum                             val exists : t -> f:(node -> bool) -> bool                             val for_all : t -> f:(node -> bool) -> bool                             val count : t -> f:(node -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(node -> 'sum) -> 'sum                             val find : t -> f:(node -> bool) -> node option                             val find_map :                               t -> f:(node -> 'a option) -> 'a option                             val to_list : t -> node list                             val to_array : t -> node array                             val invariants : t -> bool                             val mem : t -> node -> bool                             val add : t -> node -> t                             val remove : t -> node -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (node, node) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  node -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(node -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of node * node                                  | `Left of node                                  | `Right of node ] -> unit) ->                               unit                             val filter : t -> f:(node -> bool) -> t                             val partition_tf : t -> f:(node -> bool) -> t * t                             val elements : t -> node list                             val min_elt : t -> node option                             val min_elt_exn : t -> node                             val max_elt : t -> node option                             val max_elt_exn : t -> node                             val choose : t -> node option                             val choose_exn : t -> node                             val split : t -> node -> t * node option * t                             val group_by :                               t -> equiv:(node -> node -> bool) -> t list                             val find_exn : t -> f:(node -> bool) -> node                             val find_index : t -> int -> node option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t -> node Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t ->                               t ->                               node                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(node -> 'data) ->                               (node, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               node Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               node Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : node -> t                             val union_list : t list -> t                             val of_list : node list -> t                             val of_array : node array -> t                             val of_sorted_array :                               node array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : node array -> t                             val stable_dedup_list : node list -> node list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (node, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (node, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(node -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> node -> 'accum) -> 'accum                         val exists : t -> f:(node -> bool) -> bool                         val for_all : t -> f:(node -> bool) -> bool                         val count : t -> f:(node -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(node -> 'sum) -> 'sum                         val find : t -> f:(node -> bool) -> node option                         val find_map :                           t -> f:(node -> 'a option) -> 'a option                         val to_list : t -> node list                         val to_array : t -> node array                         val invariants : t -> bool                         val mem : t -> node -> bool                         val add : t -> node -> t                         val remove : t -> node -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (node, node) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> node -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(node -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of node * node                              | `Left of node                              | `Right of node ] -> unit) ->                           unit                         val filter : t -> f:(node -> bool) -> t                         val partition_tf : t -> f:(node -> bool) -> t * t                         val elements : t -> node list                         val min_elt : t -> node option                         val min_elt_exn : t -> node                         val max_elt : t -> node option                         val max_elt_exn : t -> node                         val choose : t -> node option                         val choose_exn : t -> node                         val split : t -> node -> t * node option * t                         val group_by :                           t -> equiv:(node -> node -> bool) -> t list                         val find_exn : t -> f:(node -> bool) -> node                         val find_index : t -> int -> node option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t -> node Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t ->                           t ->                           node                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(node -> 'data) ->                           (node, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           node Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           node Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : node -> t                         val union_list : t list -> t                         val of_list : node list -> t                         val of_array : node array -> t                         val of_sorted_array :                           node array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : node array -> t                         val stable_dedup_list : node list -> node list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (node, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Equiv.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> node -> bool                         val lookup : 'a t -> node -> 'a option                         val lookup_exn : 'a t -> node -> 'a                         val enqueue :                           'a t ->                           node -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> node -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (node * 'a) option                         val keys : 'a t -> node list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (node * 'a) option                         val dequeue_with_key_exn : 'a t -> node * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> node -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> node -> unit                         val replace :                           'a t -> node -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> node -> '-> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:node -> data:'-> 'b) -> 'b                       end                   end                 module Edge :                   sig                     type t = edge                     type node = Node.t                     type graph = Node.graph                     type label = EL.t                     val create : node -> node -> label -> t                     val label : t -> label                     val src : t -> node                     val dst : t -> node                     val mem : t -> graph -> bool                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = edge                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (edge, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : edge -> '-> 'a t                             val of_alist :                               (edge * 'a) list ->                               [ `Duplicate_key of edge | `Ok of 'a t ]                             val of_alist_or_error :                               (edge * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (edge * 'a) list -> 'a t                             val of_alist_multi :                               (edge * 'a) list -> 'a list t                             val of_alist_fold :                               (edge * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (edge * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (edge * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:edge -> data:'-> 'a t                             val add_multi :                               'a list t -> key:edge -> data:'-> 'a list t                             val remove_multi : 'a list t -> edge -> 'a list t                             val change :                               'a t ->                               edge -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> edge -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> edge -> 'a option                             val find_exn : 'a t -> edge -> 'a                             val remove : 'a t -> edge -> 'a t                             val mem : 'a t -> edge -> bool                             val iter :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(edge -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(edge -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:edge -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:edge ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:edge -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> edge list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (edge * 'a) list                             val validate :                               name:(edge -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:edge ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (edge, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (edge * 'a) option                             val min_elt_exn : 'a t -> edge * 'a                             val max_elt : 'a t -> (edge * 'a) option                             val max_elt_exn : 'a t -> edge * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:edge -> data:'-> bool) -> int                             val split :                               'a t ->                               edge -> 'a t * (edge * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:edge ->                               max:edge ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:edge -> max:edge -> (edge * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> edge -> (edge * 'a) option                             val nth : 'a t -> int -> (edge * 'a) option                             val rank : 'a t -> edge -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:edge ->                               ?keys_less_or_equal_to:edge ->                               'a t -> (edge * 'a) Core_kernel.Sequence.t                             val obs :                               edge Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               edge Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (edge, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : edge -> '-> 'a t                         val of_alist :                           (edge * 'a) list ->                           [ `Duplicate_key of edge | `Ok of 'a t ]                         val of_alist_or_error :                           (edge * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (edge * 'a) list -> 'a t                         val of_alist_multi : (edge * 'a) list -> 'a list t                         val of_alist_fold :                           (edge * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (edge * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (edge * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:edge -> data:'-> 'a t                         val add_multi :                           'a list t -> key:edge -> data:'-> 'a list t                         val remove_multi : 'a list t -> edge -> 'a list t                         val change :                           'a t -> edge -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> edge -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> edge -> 'a option                         val find_exn : 'a t -> edge -> 'a                         val remove : 'a t -> edge -> 'a t                         val mem : 'a t -> edge -> bool                         val iter :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(edge -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:edge -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:edge ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:edge -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> edge list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (edge * 'a) list                         val validate :                           name:(edge -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:edge ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (edge, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (edge * 'a) option                         val min_elt_exn : 'a t -> edge * 'a                         val max_elt : 'a t -> (edge * 'a) option                         val max_elt_exn : 'a t -> edge * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:edge -> data:'-> bool) -> int                         val split :                           'a t -> edge -> 'a t * (edge * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:edge ->                           max:edge ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:edge -> max:edge -> (edge * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> edge -> (edge * 'a) option                         val nth : 'a t -> int -> (edge * 'a) option                         val rank : 'a t -> edge -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:edge ->                           ?keys_less_or_equal_to:edge ->                           'a t -> (edge * 'a) Core_kernel.Sequence.t                         val obs :                           edge Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           edge Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (edge, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(edge -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> edge -> 'accum) -> 'accum                             val exists : t -> f:(edge -> bool) -> bool                             val for_all : t -> f:(edge -> bool) -> bool                             val count : t -> f:(edge -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(edge -> 'sum) -> 'sum                             val find : t -> f:(edge -> bool) -> edge option                             val find_map :                               t -> f:(edge -> 'a option) -> 'a option                             val to_list : t -> edge list                             val to_array : t -> edge array                             val invariants : t -> bool                             val mem : t -> edge -> bool                             val add : t -> edge -> t                             val remove : t -> edge -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (edge, edge) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  edge -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(edge -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of edge * edge                                  | `Left of edge                                  | `Right of edge ] -> unit) ->                               unit                             val filter : t -> f:(edge -> bool) -> t                             val partition_tf : t -> f:(edge -> bool) -> t * t                             val elements : t -> edge list                             val min_elt : t -> edge option                             val min_elt_exn : t -> edge                             val max_elt : t -> edge option                             val max_elt_exn : t -> edge                             val choose : t -> edge option                             val choose_exn : t -> edge                             val split : t -> edge -> t * edge option * t                             val group_by :                               t -> equiv:(edge -> edge -> bool) -> t list                             val find_exn : t -> f:(edge -> bool) -> edge                             val find_index : t -> int -> edge option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t -> edge Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t ->                               t ->                               edge                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(edge -> 'data) ->                               (edge, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               edge Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               edge Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : edge -> t                             val union_list : t list -> t                             val of_list : edge list -> t                             val of_array : edge array -> t                             val of_sorted_array :                               edge array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : edge array -> t                             val stable_dedup_list : edge list -> edge list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (edge, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (edge, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(edge -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> edge -> 'accum) -> 'accum                         val exists : t -> f:(edge -> bool) -> bool                         val for_all : t -> f:(edge -> bool) -> bool                         val count : t -> f:(edge -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(edge -> 'sum) -> 'sum                         val find : t -> f:(edge -> bool) -> edge option                         val find_map :                           t -> f:(edge -> 'a option) -> 'a option                         val to_list : t -> edge list                         val to_array : t -> edge array                         val invariants : t -> bool                         val mem : t -> edge -> bool                         val add : t -> edge -> t                         val remove : t -> edge -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (edge, edge) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> edge -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(edge -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of edge * edge                              | `Left of edge                              | `Right of edge ] -> unit) ->                           unit                         val filter : t -> f:(edge -> bool) -> t                         val partition_tf : t -> f:(edge -> bool) -> t * t                         val elements : t -> edge list                         val min_elt : t -> edge option                         val min_elt_exn : t -> edge                         val max_elt : t -> edge option                         val max_elt_exn : t -> edge                         val choose : t -> edge option                         val choose_exn : t -> edge                         val split : t -> edge -> t * edge option * t                         val group_by :                           t -> equiv:(edge -> edge -> bool) -> t list                         val find_exn : t -> f:(edge -> bool) -> edge                         val find_index : t -> int -> edge option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t -> edge Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t ->                           t ->                           edge                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(edge -> 'data) ->                           (edge, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           edge Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           edge Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : edge -> t                         val union_list : t list -> t                         val of_list : edge list -> t                         val of_array : edge array -> t                         val of_sorted_array :                           edge array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : edge array -> t                         val stable_dedup_list : edge list -> edge list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (edge, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Node.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> edge -> bool                         val lookup : 'a t -> edge -> 'a option                         val lookup_exn : 'a t -> edge -> 'a                         val enqueue :                           'a t ->                           edge -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> edge -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (edge * 'a) option                         val keys : 'a t -> edge list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (edge * 'a) option                         val dequeue_with_key_exn : 'a t -> edge * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> edge -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> edge -> unit                         val replace :                           'a t -> edge -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> edge -> '-> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:edge -> data:'-> 'b) -> 'b                       end                   end                 val empty : t                 val nodes : t -> node Regular.Std.seq                 val edges : t -> edge Regular.Std.seq                 val is_directed : bool                 val number_of_edges : t -> int                 val number_of_nodes : t -> int                 val ( >= ) : t -> t -> bool                 val ( <= ) : t -> t -> bool                 val ( = ) : t -> t -> bool                 val ( > ) : t -> t -> bool                 val ( < ) : t -> t -> bool                 val ( <> ) : t -> t -> bool                 val equal : t -> t -> bool                 val min : t -> t -> t                 val max : t -> t -> t                 val ascending : t -> t -> int                 val descending : t -> t -> int                 val between : t -> low:t -> high:t -> bool                 val clamp_exn : t -> min:t -> max:t -> t                 val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t                 module Replace_polymorphic_compare :                   sig                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val compare : t -> t -> int                     val min : t -> t -> t                     val max : t -> t -> t                   end                 type comparator_witness                 val comparator :                   (t, comparator_witness) Core_kernel.Comparator.comparator                 val validate_lbound :                   min:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_ubound :                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_bound :                   min:t Core_kernel.Maybe_bound.t ->                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 module Map :                   sig                     module Key :                       sig                         type t = Edge.graph                         type comparator_witness = comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type 'a t =                             (Key.t, 'a, comparator_witness)                             Core_kernel.Core_map.Tree.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val empty : 'a t                         val singleton : Key.t -> '-> 'a t                         val of_alist :                           (Key.t * 'a) list ->                           [ `Duplicate_key of Key.t | `Ok of 'a t ]                         val of_alist_or_error :                           (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (Key.t * 'a) list -> 'a t                         val of_alist_multi : (Key.t * 'a) list -> 'a list t                         val of_alist_fold :                           (Key.t * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (Key.t * 'a) array -> 'a t                         val of_tree : 'a t -> 'a t                         val gen :                           Key.t Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:Key.t -> data:'-> 'a t                         val add_multi :                           'a list t -> key:Key.t -> data:'-> 'a list t                         val remove_multi : 'a list t -> Key.t -> 'a list t                         val change :                           'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> Key.t -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> Key.t -> 'a option                         val find_exn : 'a t -> Key.t -> 'a                         val remove : 'a t -> Key.t -> 'a t                         val mem : 'a t -> Key.t -> bool                         val iter :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:Key.t -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:Key.t ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> Key.t list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (Key.t * 'a) list                         val validate :                           name:(Key.t -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (Key.t, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (Key.t * 'a) option                         val min_elt_exn : 'a t -> Key.t * 'a                         val max_elt : 'a t -> (Key.t * 'a) option                         val max_elt_exn : 'a t -> Key.t * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:Key.t -> data:'-> bool) -> int                         val split :                           'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:Key.t ->                           max:Key.t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> Key.t -> (Key.t * 'a) option                         val nth : 'a t -> int -> (Key.t * 'a) option                         val rank : 'a t -> Key.t -> int option                         val to_tree : 'a t -> 'a t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:Key.t ->                           ?keys_less_or_equal_to:Key.t ->                           'a t -> (Key.t * 'a) Core_kernel.Sequence.t                         val obs :                           Key.t Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           Key.t Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     type 'a t =                         (Key.t, 'a, comparator_witness)                         Core_kernel.Core_map.t                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val compare : ('-> '-> int) -> 'a t -> 'a t -> int                     val empty : 'a t                     val singleton : Key.t -> '-> 'a t                     val of_alist :                       (Key.t * 'a) list ->                       [ `Duplicate_key of Key.t | `Ok of 'a t ]                     val of_alist_or_error :                       (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                     val of_alist_exn : (Key.t * 'a) list -> 'a t                     val of_alist_multi : (Key.t * 'a) list -> 'a list t                     val of_alist_fold :                       (Key.t * 'a) list ->                       init:'-> f:('-> '-> 'b) -> 'b t                     val of_alist_reduce :                       (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                     val of_sorted_array :                       (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                     val of_sorted_array_unchecked :                       (Key.t * 'a) array -> 'a t                     val of_tree : 'Tree.t -> 'a t                     val gen :                       Key.t Core_kernel.Quickcheck.Generator.t ->                       'Core_kernel.Quickcheck.Generator.t ->                       'a t Core_kernel.Quickcheck.Generator.t                     val invariants : 'a t -> bool                     val is_empty : 'a t -> bool                     val length : 'a t -> int                     val add : 'a t -> key:Key.t -> data:'-> 'a t                     val add_multi :                       'a list t -> key:Key.t -> data:'-> 'a list t                     val remove_multi : 'a list t -> Key.t -> 'a list t                     val change :                       'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                     val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                     val find : 'a t -> Key.t -> 'a option                     val find_exn : 'a t -> Key.t -> 'a                     val remove : 'a t -> Key.t -> 'a t                     val mem : 'a t -> Key.t -> bool                     val iter :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                     val iter2 :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          unit) ->                       unit                     val map : 'a t -> f:('-> 'b) -> 'b t                     val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                     val fold :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold_right :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold2 :                       'a t ->                       'b t ->                       init:'->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          '-> 'c) ->                       'c                     val filter :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filteri :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                     val filter_map : 'a t -> f:('-> 'b option) -> 'b t                     val filter_mapi :                       'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                     val partition_mapi :                       'a t ->                       f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                       'b t * 'c t                     val partition_map :                       'a t ->                       f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                     val partitioni_tf :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                     val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                     val compare_direct :                       ('-> '-> int) -> 'a t -> 'a t -> int                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                     val keys : 'a t -> Key.t list                     val data : 'a t -> 'a list                     val to_alist :                       ?key_order:[ `Decreasing | `Increasing ] ->                       'a t -> (Key.t * 'a) list                     val validate :                       name:(Key.t -> string) ->                       'Core_kernel.Validate.check ->                       'a t Core_kernel.Validate.check                     val merge :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          'c option) ->                       'c t                     val symmetric_diff :                       'a t ->                       'a t ->                       data_equal:('-> '-> bool) ->                       (Key.t, 'a)                       Core_kernel.Core_map_intf.Symmetric_diff_element.t                       Core_kernel.Sequence.t                     val min_elt : 'a t -> (Key.t * 'a) option                     val min_elt_exn : 'a t -> Key.t * 'a                     val max_elt : 'a t -> (Key.t * 'a) option                     val max_elt_exn : 'a t -> Key.t * 'a                     val for_all : 'a t -> f:('-> bool) -> bool                     val for_alli :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val exists : 'a t -> f:('-> bool) -> bool                     val existsi :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val counti :                       'a t -> f:(key:Key.t -> data:'-> bool) -> int                     val split :                       'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                     val fold_range_inclusive :                       'a t ->                       min:Key.t ->                       max:Key.t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val range_to_alist :                       'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                     val closest_key :                       'a t ->                       [ `Greater_or_equal_to                       | `Greater_than                       | `Less_or_equal_to                       | `Less_than ] -> Key.t -> (Key.t * 'a) option                     val nth : 'a t -> int -> (Key.t * 'a) option                     val rank : 'a t -> Key.t -> int option                     val to_tree : 'a t -> 'Tree.t                     val to_sequence :                       ?order:[ `Decreasing_key | `Increasing_key ] ->                       ?keys_greater_or_equal_to:Key.t ->                       ?keys_less_or_equal_to:Key.t ->                       'a t -> (Key.t * 'a) Core_kernel.Sequence.t                     val obs :                       Key.t Core_kernel.Quickcheck.Observer.t ->                       'Core_kernel.Quickcheck.Observer.t ->                       'v t Core_kernel.Quickcheck.Observer.t                     val shrinker :                       Key.t Core_kernel.Quickcheck.Shrinker.t ->                       'Core_kernel.Quickcheck.Shrinker.t ->                       'v t Core_kernel.Quickcheck.Shrinker.t                   end                 module Set :                   sig                     module Elt :                       sig                         type t = Edge.graph                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type comparator_witness = Map.Key.comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type t =                             (Elt.t, comparator_witness)                             Core_kernel.Core_set.Tree.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(Elt.t -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> Elt.t -> 'accum) -> 'accum                         val exists : t -> f:(Elt.t -> bool) -> bool                         val for_all : t -> f:(Elt.t -> bool) -> bool                         val count : t -> f:(Elt.t -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(Elt.t -> 'sum) -> 'sum                         val find : t -> f:(Elt.t -> bool) -> Elt.t option                         val find_map :                           t -> f:(Elt.t -> 'a option) -> 'a option                         val to_list : t -> Elt.t list                         val to_array : t -> Elt.t array                         val invariants : t -> bool                         val mem : t -> Elt.t -> bool                         val add : t -> Elt.t -> t                         val remove : t -> Elt.t -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (Elt.t, Elt.t) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of Elt.t * Elt.t                              | `Left of Elt.t                              | `Right of Elt.t ] -> unit) ->                           unit                         val filter : t -> f:(Elt.t -> bool) -> t                         val partition_tf : t -> f:(Elt.t -> bool) -> t * t                         val elements : t -> Elt.t list                         val min_elt : t -> Elt.t option                         val min_elt_exn : t -> Elt.t                         val max_elt : t -> Elt.t option                         val max_elt_exn : t -> Elt.t                         val choose : t -> Elt.t option                         val choose_exn : t -> Elt.t                         val split : t -> Elt.t -> t * Elt.t option * t                         val group_by :                           t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                         val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                         val find_index : t -> int -> Elt.t option                         val remove_index : t -> int -> t                         val to_tree : t -> t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t -> Elt.t Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t ->                           t ->                           Elt.t                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(Elt.t -> 'data) ->                           (Elt.t, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           Elt.t Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           Elt.t Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : Elt.t -> t                         val union_list : t list -> t                         val of_list : Elt.t list -> t                         val of_array : Elt.t array -> t                         val of_sorted_array :                           Elt.t array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : Elt.t array -> t                         val stable_dedup_list : Elt.t list -> Elt.t list                         val map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t option) -> t                         val of_tree : t -> t                         val of_map_keys :                           (Elt.t, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           Elt.t Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     type t =                         (Elt.t, comparator_witness) Core_kernel.Core_set.t                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     val compare : t -> t -> int                     val length : t -> int                     val is_empty : t -> bool                     val iter : t -> f:(Elt.t -> unit) -> unit                     val fold :                       t ->                       init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                     val exists : t -> f:(Elt.t -> bool) -> bool                     val for_all : t -> f:(Elt.t -> bool) -> bool                     val count : t -> f:(Elt.t -> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       t -> f:(Elt.t -> 'sum) -> 'sum                     val find : t -> f:(Elt.t -> bool) -> Elt.t option                     val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                     val to_list : t -> Elt.t list                     val to_array : t -> Elt.t array                     val invariants : t -> bool                     val mem : t -> Elt.t -> bool                     val add : t -> Elt.t -> t                     val remove : t -> Elt.t -> t                     val union : t -> t -> t                     val inter : t -> t -> t                     val diff : t -> t -> t                     val symmetric_diff :                       t ->                       t ->                       (Elt.t, Elt.t) Core_kernel.Either.t                       Core_kernel.Sequence.t                     val compare_direct : t -> t -> int                     val equal : t -> t -> bool                     val subset : t -> t -> bool                     val fold_until :                       t ->                       init:'->                       f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                       'b                     val fold_right :                       t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                     val iter2 :                       t ->                       t ->                       f:([ `Both of Elt.t * Elt.t                          | `Left of Elt.t                          | `Right of Elt.t ] -> unit) ->                       unit                     val filter : t -> f:(Elt.t -> bool) -> t                     val partition_tf : t -> f:(Elt.t -> bool) -> t * t                     val elements : t -> Elt.t list                     val min_elt : t -> Elt.t option                     val min_elt_exn : t -> Elt.t                     val max_elt : t -> Elt.t option                     val max_elt_exn : t -> Elt.t                     val choose : t -> Elt.t option                     val choose_exn : t -> Elt.t                     val split : t -> Elt.t -> t * Elt.t option * t                     val group_by :                       t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                     val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                     val find_index : t -> int -> Elt.t option                     val remove_index : t -> int -> t                     val to_tree : t -> Tree.t                     val to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t -> Elt.t Core_kernel.Sequence.t                     val merge_to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t ->                       t ->                       Elt.t                       Core_kernel.Core_set_intf.Merge_to_sequence_element.t                       Core_kernel.Sequence.t                     val to_map :                       t ->                       f:(Elt.t -> 'data) ->                       (Elt.t, 'data, comparator_witness)                       Core_kernel.Core_set_intf.Map.t                     val obs :                       Elt.t Core_kernel.Quickcheck.obs ->                       t Core_kernel.Quickcheck.obs                     val shrinker :                       Elt.t Core_kernel.Quickcheck.shr ->                       t Core_kernel.Quickcheck.shr                     val empty : t                     val singleton : Elt.t -> t                     val union_list : t list -> t                     val of_list : Elt.t list -> t                     val of_array : Elt.t array -> t                     val of_sorted_array :                       Elt.t array -> t Core_kernel.Or_error.t                     val of_sorted_array_unchecked : Elt.t array -> t                     val stable_dedup_list : Elt.t list -> Elt.t list                     val map :                       ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t                     val filter_map :                       ('a, 'b) Core_kernel.Core_set.t ->                       f:('-> Elt.t option) -> t                     val of_tree : Tree.t -> t                     val of_map_keys :                       (Elt.t, 'a, comparator_witness)                       Core_kernel.Core_set_intf.Map.t -> t                     val gen :                       Elt.t Core_kernel.Quickcheck.Generator.t ->                       t Core_kernel.Quickcheck.Generator.t                   end                 val hash : t -> int                 val compare : t -> t -> int                 val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                 module Table :                   sig                     type key = t                     type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl                     type 'b t = (key, 'b) hashtbl                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                     type ('a, 'b) t_ = 'b t                     type 'a key_ = key                     val hashable :                       key Core_kernel.Core_hashtbl_intf.Hashable.t                     val invariant :                       'Core_kernel.Invariant_intf.inv ->                       'a t Core_kernel.Invariant_intf.inv                     val create :                       (key, 'b, unit -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_key of key | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_report_all_dups :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_or_error :                       (key, 'b,                        (key * 'b) list -> 'b t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_exn :                       (key, 'b, (key * 'b) list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_multi :                       (key, 'b list, (key * 'b) list -> 'b list t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_mapped :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key :                       (key, 'r,                        get_key:('-> key) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'r t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_or_error :                       (key, 'r,                        get_key:('-> key) ->                        'r list -> 'r t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_exn :                       (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val group :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        combine:('-> '-> 'b) -> 'r list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                     val clear : 'a t -> unit                     val copy : 'b t -> 'b t                     val fold :                       'b t ->                       init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                     val iter_vals : 'b t -> f:('-> unit) -> unit                     val iteri :                       'b t -> f:(key:key -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(key -> unit) -> unit                     val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                     val existsi :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val exists : 'b t -> f:('-> bool) -> bool                     val for_alli :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val for_all : 'b t -> f:('-> bool) -> bool                     val counti :                       'b t -> f:(key:key -> data:'-> bool) -> int                     val count : 'b t -> f:('-> bool) -> int                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val mem : 'a t -> key -> bool                     val remove : 'a t -> key -> unit                     val replace : 'b t -> key:key -> data:'-> unit                     val set : 'b t -> key:key -> data:'-> unit                     val add :                       'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                     val add_or_error :                       'b t ->                       key:key -> data:'-> unit Core_kernel.Or_error.t                     val add_exn : 'b t -> key:key -> data:'-> unit                     val change :                       'b t -> key -> f:('b option -> 'b option) -> unit                     val update : 'b t -> key -> f:('b option -> 'b) -> unit                     val add_multi : 'b list t -> key:key -> data:'-> unit                     val remove_multi : 'a list t -> key -> unit                     val map :                       ('c, 'b t -> f:('-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val mapi :                       ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_map :                       ('c, 'b t -> f:('-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_mapi :                       ('c,                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter : 'b t -> f:('-> bool) -> 'b t                     val filteri :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t                     val partition_map :                       ('c,                        ('d,                         'b t ->                         f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_mapi :                       ('c,                        ('d,                         'b t ->                         f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                         'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                     val partitioni_tf :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                     val find_or_add :                       'b t -> key -> default:(unit -> 'b) -> 'b                     val find : 'b t -> key -> 'b option                     val find_exn : 'b t -> key -> 'b                     val find_and_call :                       'b t ->                       key ->                       if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                     val find_and_remove : 'b t -> key -> 'b option                     val merge :                       ('c,                        'a t ->                        'b t ->                        f:(key:key ->                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                           'c option) ->                        'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     type 'a merge_into_action = Remove | Set_to of 'a                     val merge_into :                       src:'a t ->                       dst:'b t ->                       f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                       unit                     val keys : 'a t -> key list                     val data : 'b t -> 'b list                     val filter_inplace : 'b t -> f:('-> bool) -> unit                     val filteri_inplace :                       'b t -> f:(key:key -> data:'-> bool) -> unit                     val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                     val map_inplace : 'b t -> f:('-> 'b) -> unit                     val mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_map_inplace :                       'b t -> f:('-> 'b option) -> unit                     val filter_mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val replace_all : 'b t -> f:('-> 'b) -> unit                     val replace_alli :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_replace_all :                       'b t -> f:('-> 'b option) -> unit                     val filter_replace_alli :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                     val similar :                       'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                     val to_alist : 'b t -> (key * 'b) list                     val validate :                       name:(key -> string) ->                       'Core_kernel.Validate.check ->                       'b t Core_kernel.Validate.check                     val incr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                     val decr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   end                 module Hash_set :                   sig                     type elt = t                     type 'a hash_set = 'Edge.Hash_set.hash_set                     type t = elt hash_set                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     type 'a t_ = t                     type 'a elt_ = elt                     val create :                       ('a, unit -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                     val of_list :                       ('a, elt list -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                   end                 module Hash_queue :                   sig                     module Key :                       sig                         type t = Hash_set.elt                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val hash : t -> int                       end                     type 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val iter : 'a t -> f:('-> unit) -> unit                     val fold :                       'a t ->                       init:'accum -> f:('accum -> '-> 'accum) -> 'accum                     val exists : 'a t -> f:('-> bool) -> bool                     val for_all : 'a t -> f:('-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       'a t -> f:('-> 'sum) -> 'sum                     val find : 'a t -> f:('-> bool) -> 'a option                     val find_map : 'a t -> f:('-> 'b option) -> 'b option                     val to_list : 'a t -> 'a list                     val to_array : 'a t -> 'a array                     val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val invariant : 'a t -> unit                     val create :                       ?growth_allowed:bool -> ?size:int -> unit -> 'a t                     val clear : 'a t -> unit                     val mem : 'a t -> Key.t -> bool                     val lookup : 'a t -> Key.t -> 'a option                     val lookup_exn : 'a t -> Key.t -> 'a                     val enqueue :                       'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]                     val enqueue_exn : 'a t -> Key.t -> '-> unit                     val first : 'a t -> 'a option                     val first_with_key : 'a t -> (Key.t * 'a) option                     val keys : 'a t -> Key.t list                     val dequeue : 'a t -> 'a option                     val dequeue_exn : 'a t -> 'a                     val dequeue_with_key : 'a t -> (Key.t * 'a) option                     val dequeue_with_key_exn : 'a t -> Key.t * 'a                     val dequeue_all : 'a t -> f:('-> unit) -> unit                     val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]                     val remove_exn : 'a t -> Key.t -> unit                     val replace :                       'a t -> Key.t -> '-> [ `No_such_key | `Ok ]                     val replace_exn : 'a t -> Key.t -> '-> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val foldi :                       'a t ->                       init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b                   end                 val to_string : t -> string                 val str : unit -> t -> string                 val pps : unit -> t -> string                 val ppo : Core_kernel.Std.out_channel -> t -> unit                 val pp_seq :                   Format.formatter -> t Core_kernel.Std.Sequence.t -> unit                 val pp : Format.formatter -> t -> unit               end           val create :             (module Graphlib.Std.Graph with type t = 'and type Edge.label = 'and type Node.label = 'a) ->             ?nodes:'a list -> ?edges:('a * 'a * 'b) list -> unit -> 'c           val union :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             '-> '-> 'c           val inter :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             '-> '-> 'c           val to_dot :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?graph_attrs:('-> Graphlib.Std.graph_attr list) ->             ?node_attrs:('-> Graphlib.Std.node_attr list) ->             ?edge_attrs:('-> Graphlib.Std.edge_attr list) ->             ?string_of_node:('-> string) ->             ?string_of_edge:('-> string) ->             ?channel:Core_kernel.Std.out_channel ->             ?formatter:Format.formatter -> ?filename:string -> '-> unit           val depth_first_search :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool ->             ?start:'->             ?start_tree:('-> '-> 's) ->             ?enter_node:(int -> '-> '-> 's) ->             ?leave_node:(int -> '-> '-> 's) ->             ?enter_edge:(Graphlib.Std.edge_kind -> '-> '-> 's) ->             ?leave_edge:(Graphlib.Std.edge_kind -> '-> '-> 's) ->             '-> init:'-> 's           val depth_first_visit :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool ->             ?start:'->             '-> init:'-> ('n, 'e, 's) Graphlib.Std.dfs_visitor -> 's           class ['n, 'e, 's] dfs_identity_visitor : ['n, 'e, 's] dfs_visitor           val reverse_postorder_traverse :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool -> ?start:'-> '-> 'Regular.Std.seq           val postorder_traverse :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool -> ?start:'-> '-> 'Regular.Std.seq           val dominators :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool -> '-> '-> 'Graphlib.Std.tree           val dom_frontier :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool ->             '-> 'Graphlib.Std.tree -> 'Graphlib.Std.frontier           val strong_components :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             '-> 'Graphlib.Std.partition           val shortest_path :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?weight:('-> int) ->             ?rev:bool -> '-> '-> '-> 'Graphlib.Std.path option           val is_reachable :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool -> '-> '-> '-> bool           val fold_reachable :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?rev:bool -> init:'-> f:('-> '-> 'a) -> '-> '-> 'a           val compare :             (module Graphlib.Std.Graph with type node = 'and type t = 'a) ->             (module Graphlib.Std.Graph with type node = 'and type t = 'b) ->             '-> '-> int           val filtered :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->             ?skip_node:('-> bool) ->             ?skip_edge:('-> bool) ->             unit ->             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c)           val view :             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'and type Edge.label = 'and type Node.label = 'a) ->             node:('-> 'f) * ('-> 'n) ->             edge:('-> 'd) * ('-> 'e) ->             node_label:('-> 'p) * ('-> 'a) ->             edge_label:('-> 'r) * ('-> 'b) ->             (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'and type Edge.label = 'and type Node.label = 'p)           module To_ocamlgraph :             functor (G : Graph->               sig                 type t = G.t                 module V :                   sig                     type t = G.node                     val compare : t -> t -> int                     val hash : t -> int                     val equal : t -> t -> bool                     type label = G.Node.label                     val create : label -> t                     val label : t -> label                   end                 type vertex = V.t                 module E :                   sig                     type t = G.edge                     val compare : t -> t -> int                     type vertex = V.t                     val src : t -> vertex                     val dst : t -> vertex                     type label = G.Edge.label                     val create : vertex -> label -> vertex -> t                     val label : t -> label                   end                 type edge = E.t                 val is_directed : bool                 val is_empty : t -> bool                 val nb_vertex : t -> int                 val nb_edges : t -> int                 val out_degree : t -> vertex -> int                 val in_degree : t -> vertex -> int                 val mem_vertex : t -> vertex -> bool                 val mem_edge : t -> vertex -> vertex -> bool                 val mem_edge_e : t -> edge -> bool                 val find_edge : t -> vertex -> vertex -> edge                 val find_all_edges : t -> vertex -> vertex -> edge list                 val succ : t -> vertex -> vertex list                 val pred : t -> vertex -> vertex list                 val succ_e : t -> vertex -> edge list                 val pred_e : t -> vertex -> edge list                 val iter_vertex : (vertex -> unit) -> t -> unit                 val fold_vertex : (vertex -> '-> 'a) -> t -> '-> 'a                 val iter_edges : (vertex -> vertex -> unit) -> t -> unit                 val fold_edges :                   (vertex -> vertex -> '-> 'a) -> t -> '-> 'a                 val iter_edges_e : (edge -> unit) -> t -> unit                 val fold_edges_e : (edge -> '-> 'a) -> t -> '-> 'a                 val map_vertex : (vertex -> vertex) -> t -> t                 val iter_succ : (vertex -> unit) -> t -> vertex -> unit                 val iter_pred : (vertex -> unit) -> t -> vertex -> unit                 val fold_succ :                   (vertex -> '-> 'a) -> t -> vertex -> '-> 'a                 val fold_pred :                   (vertex -> '-> 'a) -> t -> vertex -> '-> 'a                 val iter_succ_e : (edge -> unit) -> t -> vertex -> unit                 val fold_succ_e :                   (edge -> '-> 'a) -> t -> vertex -> '-> 'a                 val iter_pred_e : (edge -> unit) -> t -> vertex -> unit                 val fold_pred_e :                   (edge -> '-> 'a) -> t -> vertex -> '-> 'a                 val empty : t                 val add_vertex : t -> vertex -> t                 val remove_vertex : t -> vertex -> t                 val add_edge : t -> vertex -> vertex -> t                 val add_edge_e : t -> edge -> t                 val remove_edge : t -> vertex -> vertex -> t                 val remove_edge_e : t -> edge -> t               end           module Of_ocamlgraph :             functor (G : Graph.Sig.P->               sig                 type t = G.t                 type node = G.V.t                 type edge = G.E.t                 module Node :                   sig                     type t = node                     type graph = G.t                     type label = G.V.label                     type edge = G.E.t                     val create : label -> t                     val label : t -> label                     val mem : t -> graph -> bool                     val succs : t -> graph -> t Regular.Std.seq                     val preds : t -> graph -> t Regular.Std.seq                     val inputs : t -> graph -> edge Regular.Std.seq                     val outputs : t -> graph -> edge Regular.Std.seq                     val degree : ?dir:[ `In | `Out ] -> t -> graph -> int                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val has_edge : t -> t -> graph -> bool                     val edge : t -> t -> graph -> edge option                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = node                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (node, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : node -> '-> 'a t                             val of_alist :                               (node * 'a) list ->                               [ `Duplicate_key of node | `Ok of 'a t ]                             val of_alist_or_error :                               (node * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (node * 'a) list -> 'a t                             val of_alist_multi :                               (node * 'a) list -> 'a list t                             val of_alist_fold :                               (node * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (node * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (node * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (node * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:node -> data:'-> 'a t                             val add_multi :                               'a list t -> key:node -> data:'-> 'a list t                             val remove_multi : 'a list t -> node -> 'a list t                             val change :                               'a t ->                               node -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> node -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> node -> 'a option                             val find_exn : 'a t -> node -> 'a                             val remove : 'a t -> node -> 'a t                             val mem : 'a t -> node -> bool                             val iter :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(node -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:node -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(node -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:node -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:node ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:node -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> node list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (node * 'a) list                             val validate :                               name:(node -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:node ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (node, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (node * 'a) option                             val min_elt_exn : 'a t -> node * 'a                             val max_elt : 'a t -> (node * 'a) option                             val max_elt_exn : 'a t -> node * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:node -> data:'-> bool) -> int                             val split :                               'a t ->                               node -> 'a t * (node * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:node ->                               max:node ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:node -> max:node -> (node * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> node -> (node * 'a) option                             val nth : 'a t -> int -> (node * 'a) option                             val rank : 'a t -> node -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:node ->                               ?keys_less_or_equal_to:node ->                               'a t -> (node * 'a) Core_kernel.Sequence.t                             val obs :                               node Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               node Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (node, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : node -> '-> 'a t                         val of_alist :                           (node * 'a) list ->                           [ `Duplicate_key of node | `Ok of 'a t ]                         val of_alist_or_error :                           (node * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (node * 'a) list -> 'a t                         val of_alist_multi : (node * 'a) list -> 'a list t                         val of_alist_fold :                           (node * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (node * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (node * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (node * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:node -> data:'-> 'a t                         val add_multi :                           'a list t -> key:node -> data:'-> 'a list t                         val remove_multi : 'a list t -> node -> 'a list t                         val change :                           'a t -> node -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> node -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> node -> 'a option                         val find_exn : 'a t -> node -> 'a                         val remove : 'a t -> node -> 'a t                         val mem : 'a t -> node -> bool                         val iter :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(node -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:node -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(node -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:node -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:node ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:node -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> node list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (node * 'a) list                         val validate :                           name:(node -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:node ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (node, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (node * 'a) option                         val min_elt_exn : 'a t -> node * 'a                         val max_elt : 'a t -> (node * 'a) option                         val max_elt_exn : 'a t -> node * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:node -> data:'-> bool) -> int                         val split :                           'a t -> node -> 'a t * (node * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:node ->                           max:node ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:node -> max:node -> (node * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> node -> (node * 'a) option                         val nth : 'a t -> int -> (node * 'a) option                         val rank : 'a t -> node -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:node ->                           ?keys_less_or_equal_to:node ->                           'a t -> (node * 'a) Core_kernel.Sequence.t                         val obs :                           node Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           node Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (node, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(node -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> node -> 'accum) -> 'accum                             val exists : t -> f:(node -> bool) -> bool                             val for_all : t -> f:(node -> bool) -> bool                             val count : t -> f:(node -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(node -> 'sum) -> 'sum                             val find : t -> f:(node -> bool) -> node option                             val find_map :                               t -> f:(node -> 'a option) -> 'a option                             val to_list : t -> node list                             val to_array : t -> node array                             val invariants : t -> bool                             val mem : t -> node -> bool                             val add : t -> node -> t                             val remove : t -> node -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (node, node) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  node -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(node -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of node * node                                  | `Left of node                                  | `Right of node ] -> unit) ->                               unit                             val filter : t -> f:(node -> bool) -> t                             val partition_tf : t -> f:(node -> bool) -> t * t                             val elements : t -> node list                             val min_elt : t -> node option                             val min_elt_exn : t -> node                             val max_elt : t -> node option                             val max_elt_exn : t -> node                             val choose : t -> node option                             val choose_exn : t -> node                             val split : t -> node -> t * node option * t                             val group_by :                               t -> equiv:(node -> node -> bool) -> t list                             val find_exn : t -> f:(node -> bool) -> node                             val find_index : t -> int -> node option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t -> node Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t ->                               t ->                               node                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(node -> 'data) ->                               (node, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               node Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               node Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : node -> t                             val union_list : t list -> t                             val of_list : node list -> t                             val of_array : node array -> t                             val of_sorted_array :                               node array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : node array -> t                             val stable_dedup_list : node list -> node list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (node, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (node, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(node -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> node -> 'accum) -> 'accum                         val exists : t -> f:(node -> bool) -> bool                         val for_all : t -> f:(node -> bool) -> bool                         val count : t -> f:(node -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(node -> 'sum) -> 'sum                         val find : t -> f:(node -> bool) -> node option                         val find_map :                           t -> f:(node -> 'a option) -> 'a option                         val to_list : t -> node list                         val to_array : t -> node array                         val invariants : t -> bool                         val mem : t -> node -> bool                         val add : t -> node -> t                         val remove : t -> node -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (node, node) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> node -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(node -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of node * node                              | `Left of node                              | `Right of node ] -> unit) ->                           unit                         val filter : t -> f:(node -> bool) -> t                         val partition_tf : t -> f:(node -> bool) -> t * t                         val elements : t -> node list                         val min_elt : t -> node option                         val min_elt_exn : t -> node                         val max_elt : t -> node option                         val max_elt_exn : t -> node                         val choose : t -> node option                         val choose_exn : t -> node                         val split : t -> node -> t * node option * t                         val group_by :                           t -> equiv:(node -> node -> bool) -> t list                         val find_exn : t -> f:(node -> bool) -> node                         val find_index : t -> int -> node option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t -> node Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t ->                           t ->                           node                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(node -> 'data) ->                           (node, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           node Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           node Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : node -> t                         val union_list : t list -> t                         val of_list : node list -> t                         val of_array : node array -> t                         val of_sorted_array :                           node array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : node array -> t                         val stable_dedup_list : node list -> node list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (node, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Equiv.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> node -> bool                         val lookup : 'a t -> node -> 'a option                         val lookup_exn : 'a t -> node -> 'a                         val enqueue :                           'a t ->                           node -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> node -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (node * 'a) option                         val keys : 'a t -> node list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (node * 'a) option                         val dequeue_with_key_exn : 'a t -> node * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> node -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> node -> unit                         val replace :                           'a t -> node -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> node -> '-> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:node -> data:'-> 'b) -> 'b                       end                   end                 module Edge :                   sig                     type t = edge                     type node = Node.t                     type graph = Node.graph                     type label = G.E.label                     val create : node -> node -> label -> t                     val label : t -> label                     val src : t -> node                     val dst : t -> node                     val mem : t -> graph -> bool                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = edge                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (edge, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : edge -> '-> 'a t                             val of_alist :                               (edge * 'a) list ->                               [ `Duplicate_key of edge | `Ok of 'a t ]                             val of_alist_or_error :                               (edge * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (edge * 'a) list -> 'a t                             val of_alist_multi :                               (edge * 'a) list -> 'a list t                             val of_alist_fold :                               (edge * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (edge * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (edge * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:edge -> data:'-> 'a t                             val add_multi :                               'a list t -> key:edge -> data:'-> 'a list t                             val remove_multi : 'a list t -> edge -> 'a list t                             val change :                               'a t ->                               edge -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> edge -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> edge -> 'a option                             val find_exn : 'a t -> edge -> 'a                             val remove : 'a t -> edge -> 'a t                             val mem : 'a t -> edge -> bool                             val iter :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(edge -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(edge -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:edge -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:edge ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:edge -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> edge list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (edge * 'a) list                             val validate :                               name:(edge -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:edge ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (edge, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (edge * 'a) option                             val min_elt_exn : 'a t -> edge * 'a                             val max_elt : 'a t -> (edge * 'a) option                             val max_elt_exn : 'a t -> edge * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:edge -> data:'-> bool) -> int                             val split :                               'a t ->                               edge -> 'a t * (edge * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:edge ->                               max:edge ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:edge -> max:edge -> (edge * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> edge -> (edge * 'a) option                             val nth : 'a t -> int -> (edge * 'a) option                             val rank : 'a t -> edge -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:edge ->                               ?keys_less_or_equal_to:edge ->                               'a t -> (edge * 'a) Core_kernel.Sequence.t                             val obs :                               edge Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               edge Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (edge, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : edge -> '-> 'a t                         val of_alist :                           (edge * 'a) list ->                           [ `Duplicate_key of edge | `Ok of 'a t ]                         val of_alist_or_error :                           (edge * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (edge * 'a) list -> 'a t                         val of_alist_multi : (edge * 'a) list -> 'a list t                         val of_alist_fold :                           (edge * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (edge * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (edge * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:edge -> data:'-> 'a t                         val add_multi :                           'a list t -> key:edge -> data:'-> 'a list t                         val remove_multi : 'a list t -> edge -> 'a list t                         val change :                           'a t -> edge -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> edge -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> edge -> 'a option                         val find_exn : 'a t -> edge -> 'a                         val remove : 'a t -> edge -> 'a t                         val mem : 'a t -> edge -> bool                         val iter :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(edge -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:edge -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:edge ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:edge -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> edge list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (edge * 'a) list                         val validate :                           name:(edge -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:edge ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (edge, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (edge * 'a) option                         val min_elt_exn : 'a t -> edge * 'a                         val max_elt : 'a t -> (edge * 'a) option                         val max_elt_exn : 'a t -> edge * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:edge -> data:'-> bool) -> int                         val split :                           'a t -> edge -> 'a t * (edge * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:edge ->                           max:edge ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:edge -> max:edge -> (edge * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> edge -> (edge * 'a) option                         val nth : 'a t -> int -> (edge * 'a) option                         val rank : 'a t -> edge -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:edge ->                           ?keys_less_or_equal_to:edge ->                           'a t -> (edge * 'a) Core_kernel.Sequence.t                         val obs :                           edge Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           edge Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (edge, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(edge -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> edge -> 'accum) -> 'accum                             val exists : t -> f:(edge -> bool) -> bool                             val for_all : t -> f:(edge -> bool) -> bool                             val count : t -> f:(edge -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(edge -> 'sum) -> 'sum                             val find : t -> f:(edge -> bool) -> edge option                             val find_map :                               t -> f:(edge -> 'a option) -> 'a option                             val to_list : t -> edge list                             val to_array : t -> edge array                             val invariants : t -> bool                             val mem : t -> edge -> bool                             val add : t -> edge -> t                             val remove : t -> edge -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (edge, edge) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  edge -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(edge -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of edge * edge                                  | `Left of edge                                  | `Right of edge ] -> unit) ->                               unit                             val filter : t -> f:(edge -> bool) -> t                             val partition_tf : t -> f:(edge -> bool) -> t * t                             val elements : t -> edge list                             val min_elt : t -> edge option                             val min_elt_exn : t -> edge                             val max_elt : t -> edge option                             val max_elt_exn : t -> edge                             val choose : t -> edge option                             val choose_exn : t -> edge                             val split : t -> edge -> t * edge option * t                             val group_by :                               t -> equiv:(edge -> edge -> bool) -> t list                             val find_exn : t -> f:(edge -> bool) -> edge                             val find_index : t -> int -> edge option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t -> edge Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t ->                               t ->                               edge                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(edge -> 'data) ->                               (edge, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               edge Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               edge Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : edge -> t                             val union_list : t list -> t                             val of_list : edge list -> t                             val of_array : edge array -> t                             val of_sorted_array :                               edge array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : edge array -> t                             val stable_dedup_list : edge list -> edge list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (edge, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (edge, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(edge -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> edge -> 'accum) -> 'accum                         val exists : t -> f:(edge -> bool) -> bool                         val for_all : t -> f:(edge -> bool) -> bool                         val count : t -> f:(edge -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(edge -> 'sum) -> 'sum                         val find : t -> f:(edge -> bool) -> edge option                         val find_map :                           t -> f:(edge -> 'a option) -> 'a option                         val to_list : t -> edge list                         val to_array : t -> edge array                         val invariants : t -> bool                         val mem : t -> edge -> bool                         val add : t -> edge -> t                         val remove : t -> edge -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (edge, edge) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> edge -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(edge -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of edge * edge                              | `Left of edge                              | `Right of edge ] -> unit) ->                           unit                         val filter : t -> f:(edge -> bool) -> t                         val partition_tf : t -> f:(edge -> bool) -> t * t                         val elements : t -> edge list                         val min_elt : t -> edge option                         val min_elt_exn : t -> edge                         val max_elt : t -> edge option                         val max_elt_exn : t -> edge                         val choose : t -> edge option                         val choose_exn : t -> edge                         val split : t -> edge -> t * edge option * t                         val group_by :                           t -> equiv:(edge -> edge -> bool) -> t list                         val find_exn : t -> f:(edge -> bool) -> edge                         val find_index : t -> int -> edge option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t -> edge Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t ->                           t ->                           edge                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(edge -> 'data) ->                           (edge, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           edge Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           edge Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : edge -> t                         val union_list : t list -> t                         val of_list : edge list -> t                         val of_array : edge array -> t                         val of_sorted_array :                           edge array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : edge array -> t                         val stable_dedup_list : edge list -> edge list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (edge, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Node.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> edge -> bool                         val lookup : 'a t -> edge -> 'a option                         val lookup_exn : 'a t -> edge -> 'a                         val enqueue :                           'a t ->                           edge -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> edge -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (edge * 'a) option                         val keys : 'a t -> edge list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (edge * 'a) option                         val dequeue_with_key_exn : 'a t -> edge * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> edge -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> edge -> unit                         val replace :                           'a t -> edge -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> edge -> '-> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:edge -> data:'-> 'b) -> 'b                       end                   end                 val empty : t                 val nodes : t -> node Regular.Std.seq                 val edges : t -> edge Regular.Std.seq                 val is_directed : bool                 val number_of_edges : t -> int                 val number_of_nodes : t -> int                 val ( >= ) : t -> t -> bool                 val ( <= ) : t -> t -> bool                 val ( = ) : t -> t -> bool                 val ( > ) : t -> t -> bool                 val ( < ) : t -> t -> bool                 val ( <> ) : t -> t -> bool                 val equal : t -> t -> bool                 val min : t -> t -> t                 val max : t -> t -> t                 val ascending : t -> t -> int                 val descending : t -> t -> int                 val between : t -> low:t -> high:t -> bool                 val clamp_exn : t -> min:t -> max:t -> t                 val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t                 module Replace_polymorphic_compare :                   sig                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val compare : t -> t -> int                     val min : t -> t -> t                     val max : t -> t -> t                   end                 type comparator_witness                 val comparator :                   (t, comparator_witness) Core_kernel.Comparator.comparator                 val validate_lbound :                   min:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_ubound :                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_bound :                   min:t Core_kernel.Maybe_bound.t ->                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 module Map :                   sig                     module Key :                       sig                         type t = Edge.graph                         type comparator_witness = comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type 'a t =                             (Key.t, 'a, comparator_witness)                             Core_kernel.Core_map.Tree.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val empty : 'a t                         val singleton : Key.t -> '-> 'a t                         val of_alist :                           (Key.t * 'a) list ->                           [ `Duplicate_key of Key.t | `Ok of 'a t ]                         val of_alist_or_error :                           (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (Key.t * 'a) list -> 'a t                         val of_alist_multi : (Key.t * 'a) list -> 'a list t                         val of_alist_fold :                           (Key.t * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (Key.t * 'a) array -> 'a t                         val of_tree : 'a t -> 'a t                         val gen :                           Key.t Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:Key.t -> data:'-> 'a t                         val add_multi :                           'a list t -> key:Key.t -> data:'-> 'a list t                         val remove_multi : 'a list t -> Key.t -> 'a list t                         val change :                           'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> Key.t -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> Key.t -> 'a option                         val find_exn : 'a t -> Key.t -> 'a                         val remove : 'a t -> Key.t -> 'a t                         val mem : 'a t -> Key.t -> bool                         val iter :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:Key.t -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:Key.t ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> Key.t list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (Key.t * 'a) list                         val validate :                           name:(Key.t -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (Key.t, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (Key.t * 'a) option                         val min_elt_exn : 'a t -> Key.t * 'a                         val max_elt : 'a t -> (Key.t * 'a) option                         val max_elt_exn : 'a t -> Key.t * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:Key.t -> data:'-> bool) -> int                         val split :                           'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:Key.t ->                           max:Key.t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> Key.t -> (Key.t * 'a) option                         val nth : 'a t -> int -> (Key.t * 'a) option                         val rank : 'a t -> Key.t -> int option                         val to_tree : 'a t -> 'a t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:Key.t ->                           ?keys_less_or_equal_to:Key.t ->                           'a t -> (Key.t * 'a) Core_kernel.Sequence.t                         val obs :                           Key.t Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           Key.t Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     type 'a t =                         (Key.t, 'a, comparator_witness)                         Core_kernel.Core_map.t                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val compare : ('-> '-> int) -> 'a t -> 'a t -> int                     val empty : 'a t                     val singleton : Key.t -> '-> 'a t                     val of_alist :                       (Key.t * 'a) list ->                       [ `Duplicate_key of Key.t | `Ok of 'a t ]                     val of_alist_or_error :                       (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                     val of_alist_exn : (Key.t * 'a) list -> 'a t                     val of_alist_multi : (Key.t * 'a) list -> 'a list t                     val of_alist_fold :                       (Key.t * 'a) list ->                       init:'-> f:('-> '-> 'b) -> 'b t                     val of_alist_reduce :                       (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                     val of_sorted_array :                       (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                     val of_sorted_array_unchecked :                       (Key.t * 'a) array -> 'a t                     val of_tree : 'Tree.t -> 'a t                     val gen :                       Key.t Core_kernel.Quickcheck.Generator.t ->                       'Core_kernel.Quickcheck.Generator.t ->                       'a t Core_kernel.Quickcheck.Generator.t                     val invariants : 'a t -> bool                     val is_empty : 'a t -> bool                     val length : 'a t -> int                     val add : 'a t -> key:Key.t -> data:'-> 'a t                     val add_multi :                       'a list t -> key:Key.t -> data:'-> 'a list t                     val remove_multi : 'a list t -> Key.t -> 'a list t                     val change :                       'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                     val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                     val find : 'a t -> Key.t -> 'a option                     val find_exn : 'a t -> Key.t -> 'a                     val remove : 'a t -> Key.t -> 'a t                     val mem : 'a t -> Key.t -> bool                     val iter :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                     val iter2 :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          unit) ->                       unit                     val map : 'a t -> f:('-> 'b) -> 'b t                     val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                     val fold :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold_right :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold2 :                       'a t ->                       'b t ->                       init:'->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          '-> 'c) ->                       'c                     val filter :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filteri :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                     val filter_map : 'a t -> f:('-> 'b option) -> 'b t                     val filter_mapi :                       'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                     val partition_mapi :                       'a t ->                       f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                       'b t * 'c t                     val partition_map :                       'a t ->                       f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                     val partitioni_tf :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                     val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                     val compare_direct :                       ('-> '-> int) -> 'a t -> 'a t -> int                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                     val keys : 'a t -> Key.t list                     val data : 'a t -> 'a list                     val to_alist :                       ?key_order:[ `Decreasing | `Increasing ] ->                       'a t -> (Key.t * 'a) list                     val validate :                       name:(Key.t -> string) ->                       'Core_kernel.Validate.check ->                       'a t Core_kernel.Validate.check                     val merge :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          'c option) ->                       'c t                     val symmetric_diff :                       'a t ->                       'a t ->                       data_equal:('-> '-> bool) ->                       (Key.t, 'a)                       Core_kernel.Core_map_intf.Symmetric_diff_element.t                       Core_kernel.Sequence.t                     val min_elt : 'a t -> (Key.t * 'a) option                     val min_elt_exn : 'a t -> Key.t * 'a                     val max_elt : 'a t -> (Key.t * 'a) option                     val max_elt_exn : 'a t -> Key.t * 'a                     val for_all : 'a t -> f:('-> bool) -> bool                     val for_alli :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val exists : 'a t -> f:('-> bool) -> bool                     val existsi :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val counti :                       'a t -> f:(key:Key.t -> data:'-> bool) -> int                     val split :                       'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                     val fold_range_inclusive :                       'a t ->                       min:Key.t ->                       max:Key.t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val range_to_alist :                       'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                     val closest_key :                       'a t ->                       [ `Greater_or_equal_to                       | `Greater_than                       | `Less_or_equal_to                       | `Less_than ] -> Key.t -> (Key.t * 'a) option                     val nth : 'a t -> int -> (Key.t * 'a) option                     val rank : 'a t -> Key.t -> int option                     val to_tree : 'a t -> 'Tree.t                     val to_sequence :                       ?order:[ `Decreasing_key | `Increasing_key ] ->                       ?keys_greater_or_equal_to:Key.t ->                       ?keys_less_or_equal_to:Key.t ->                       'a t -> (Key.t * 'a) Core_kernel.Sequence.t                     val obs :                       Key.t Core_kernel.Quickcheck.Observer.t ->                       'Core_kernel.Quickcheck.Observer.t ->                       'v t Core_kernel.Quickcheck.Observer.t                     val shrinker :                       Key.t Core_kernel.Quickcheck.Shrinker.t ->                       'Core_kernel.Quickcheck.Shrinker.t ->                       'v t Core_kernel.Quickcheck.Shrinker.t                   end                 module Set :                   sig                     module Elt :                       sig                         type t = Edge.graph                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type comparator_witness = Map.Key.comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type t =                             (Elt.t, comparator_witness)                             Core_kernel.Core_set.Tree.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(Elt.t -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> Elt.t -> 'accum) -> 'accum                         val exists : t -> f:(Elt.t -> bool) -> bool                         val for_all : t -> f:(Elt.t -> bool) -> bool                         val count : t -> f:(Elt.t -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(Elt.t -> 'sum) -> 'sum                         val find : t -> f:(Elt.t -> bool) -> Elt.t option                         val find_map :                           t -> f:(Elt.t -> 'a option) -> 'a option                         val to_list : t -> Elt.t list                         val to_array : t -> Elt.t array                         val invariants : t -> bool                         val mem : t -> Elt.t -> bool                         val add : t -> Elt.t -> t                         val remove : t -> Elt.t -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (Elt.t, Elt.t) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of Elt.t * Elt.t                              | `Left of Elt.t                              | `Right of Elt.t ] -> unit) ->                           unit                         val filter : t -> f:(Elt.t -> bool) -> t                         val partition_tf : t -> f:(Elt.t -> bool) -> t * t                         val elements : t -> Elt.t list                         val min_elt : t -> Elt.t option                         val min_elt_exn : t -> Elt.t                         val max_elt : t -> Elt.t option                         val max_elt_exn : t -> Elt.t                         val choose : t -> Elt.t option                         val choose_exn : t -> Elt.t                         val split : t -> Elt.t -> t * Elt.t option * t                         val group_by :                           t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                         val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                         val find_index : t -> int -> Elt.t option                         val remove_index : t -> int -> t                         val to_tree : t -> t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t -> Elt.t Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t ->                           t ->                           Elt.t                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(Elt.t -> 'data) ->                           (Elt.t, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           Elt.t Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           Elt.t Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : Elt.t -> t                         val union_list : t list -> t                         val of_list : Elt.t list -> t                         val of_array : Elt.t array -> t                         val of_sorted_array :                           Elt.t array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : Elt.t array -> t                         val stable_dedup_list : Elt.t list -> Elt.t list                         val map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t option) -> t                         val of_tree : t -> t                         val of_map_keys :                           (Elt.t, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           Elt.t Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     type t =                         (Elt.t, comparator_witness) Core_kernel.Core_set.t                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     val compare : t -> t -> int                     val length : t -> int                     val is_empty : t -> bool                     val iter : t -> f:(Elt.t -> unit) -> unit                     val fold :                       t ->                       init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                     val exists : t -> f:(Elt.t -> bool) -> bool                     val for_all : t -> f:(Elt.t -> bool) -> bool                     val count : t -> f:(Elt.t -> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       t -> f:(Elt.t -> 'sum) -> 'sum                     val find : t -> f:(Elt.t -> bool) -> Elt.t option                     val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                     val to_list : t -> Elt.t list                     val to_array : t -> Elt.t array                     val invariants : t -> bool                     val mem : t -> Elt.t -> bool                     val add : t -> Elt.t -> t                     val remove : t -> Elt.t -> t                     val union : t -> t -> t                     val inter : t -> t -> t                     val diff : t -> t -> t                     val symmetric_diff :                       t ->                       t ->                       (Elt.t, Elt.t) Core_kernel.Either.t                       Core_kernel.Sequence.t                     val compare_direct : t -> t -> int                     val equal : t -> t -> bool                     val subset : t -> t -> bool                     val fold_until :                       t ->                       init:'->                       f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                       'b                     val fold_right :                       t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                     val iter2 :                       t ->                       t ->                       f:([ `Both of Elt.t * Elt.t                          | `Left of Elt.t                          | `Right of Elt.t ] -> unit) ->                       unit                     val filter : t -> f:(Elt.t -> bool) -> t                     val partition_tf : t -> f:(Elt.t -> bool) -> t * t                     val elements : t -> Elt.t list                     val min_elt : t -> Elt.t option                     val min_elt_exn : t -> Elt.t                     val max_elt : t -> Elt.t option                     val max_elt_exn : t -> Elt.t                     val choose : t -> Elt.t option                     val choose_exn : t -> Elt.t                     val split : t -> Elt.t -> t * Elt.t option * t                     val group_by :                       t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                     val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                     val find_index : t -> int -> Elt.t option                     val remove_index : t -> int -> t                     val to_tree : t -> Tree.t                     val to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t -> Elt.t Core_kernel.Sequence.t                     val merge_to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t ->                       t ->                       Elt.t                       Core_kernel.Core_set_intf.Merge_to_sequence_element.t                       Core_kernel.Sequence.t                     val to_map :                       t ->                       f:(Elt.t -> 'data) ->                       (Elt.t, 'data, comparator_witness)                       Core_kernel.Core_set_intf.Map.t                     val obs :                       Elt.t Core_kernel.Quickcheck.obs ->                       t Core_kernel.Quickcheck.obs                     val shrinker :                       Elt.t Core_kernel.Quickcheck.shr ->                       t Core_kernel.Quickcheck.shr                     val empty : t                     val singleton : Elt.t -> t                     val union_list : t list -> t                     val of_list : Elt.t list -> t                     val of_array : Elt.t array -> t                     val of_sorted_array :                       Elt.t array -> t Core_kernel.Or_error.t                     val of_sorted_array_unchecked : Elt.t array -> t                     val stable_dedup_list : Elt.t list -> Elt.t list                     val map :                       ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t                     val filter_map :                       ('a, 'b) Core_kernel.Core_set.t ->                       f:('-> Elt.t option) -> t                     val of_tree : Tree.t -> t                     val of_map_keys :                       (Elt.t, 'a, comparator_witness)                       Core_kernel.Core_set_intf.Map.t -> t                     val gen :                       Elt.t Core_kernel.Quickcheck.Generator.t ->                       t Core_kernel.Quickcheck.Generator.t                   end                 val hash : t -> int                 val compare : t -> t -> int                 val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                 module Table :                   sig                     type key = t                     type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl                     type 'b t = (key, 'b) hashtbl                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                     type ('a, 'b) t_ = 'b t                     type 'a key_ = key                     val hashable :                       key Core_kernel.Core_hashtbl_intf.Hashable.t                     val invariant :                       'Core_kernel.Invariant_intf.inv ->                       'a t Core_kernel.Invariant_intf.inv                     val create :                       (key, 'b, unit -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_key of key | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_report_all_dups :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_or_error :                       (key, 'b,                        (key * 'b) list -> 'b t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_exn :                       (key, 'b, (key * 'b) list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_multi :                       (key, 'b list, (key * 'b) list -> 'b list t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_mapped :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key :                       (key, 'r,                        get_key:('-> key) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'r t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_or_error :                       (key, 'r,                        get_key:('-> key) ->                        'r list -> 'r t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_exn :                       (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val group :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        combine:('-> '-> 'b) -> 'r list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                     val clear : 'a t -> unit                     val copy : 'b t -> 'b t                     val fold :                       'b t ->                       init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                     val iter_vals : 'b t -> f:('-> unit) -> unit                     val iteri :                       'b t -> f:(key:key -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(key -> unit) -> unit                     val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                     val existsi :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val exists : 'b t -> f:('-> bool) -> bool                     val for_alli :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val for_all : 'b t -> f:('-> bool) -> bool                     val counti :                       'b t -> f:(key:key -> data:'-> bool) -> int                     val count : 'b t -> f:('-> bool) -> int                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val mem : 'a t -> key -> bool                     val remove : 'a t -> key -> unit                     val replace : 'b t -> key:key -> data:'-> unit                     val set : 'b t -> key:key -> data:'-> unit                     val add :                       'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                     val add_or_error :                       'b t ->                       key:key -> data:'-> unit Core_kernel.Or_error.t                     val add_exn : 'b t -> key:key -> data:'-> unit                     val change :                       'b t -> key -> f:('b option -> 'b option) -> unit                     val update : 'b t -> key -> f:('b option -> 'b) -> unit                     val add_multi : 'b list t -> key:key -> data:'-> unit                     val remove_multi : 'a list t -> key -> unit                     val map :                       ('c, 'b t -> f:('-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val mapi :                       ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_map :                       ('c, 'b t -> f:('-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_mapi :                       ('c,                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter : 'b t -> f:('-> bool) -> 'b t                     val filteri :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t                     val partition_map :                       ('c,                        ('d,                         'b t ->                         f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_mapi :                       ('c,                        ('d,                         'b t ->                         f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                         'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                     val partitioni_tf :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                     val find_or_add :                       'b t -> key -> default:(unit -> 'b) -> 'b                     val find : 'b t -> key -> 'b option                     val find_exn : 'b t -> key -> 'b                     val find_and_call :                       'b t ->                       key ->                       if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                     val find_and_remove : 'b t -> key -> 'b option                     val merge :                       ('c,                        'a t ->                        'b t ->                        f:(key:key ->                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                           'c option) ->                        'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     type 'a merge_into_action = Remove | Set_to of 'a                     val merge_into :                       src:'a t ->                       dst:'b t ->                       f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                       unit                     val keys : 'a t -> key list                     val data : 'b t -> 'b list                     val filter_inplace : 'b t -> f:('-> bool) -> unit                     val filteri_inplace :                       'b t -> f:(key:key -> data:'-> bool) -> unit                     val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                     val map_inplace : 'b t -> f:('-> 'b) -> unit                     val mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_map_inplace :                       'b t -> f:('-> 'b option) -> unit                     val filter_mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val replace_all : 'b t -> f:('-> 'b) -> unit                     val replace_alli :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_replace_all :                       'b t -> f:('-> 'b option) -> unit                     val filter_replace_alli :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                     val similar :                       'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                     val to_alist : 'b t -> (key * 'b) list                     val validate :                       name:(key -> string) ->                       'Core_kernel.Validate.check ->                       'b t Core_kernel.Validate.check                     val incr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                     val decr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   end                 module Hash_set :                   sig                     type elt = t                     type 'a hash_set = 'Edge.Hash_set.hash_set                     type t = elt hash_set                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     type 'a t_ = t                     type 'a elt_ = elt                     val create :                       ('a, unit -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                     val of_list :                       ('a, elt list -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                   end                 module Hash_queue :                   sig                     module Key :                       sig                         type t = Hash_set.elt                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val hash : t -> int                       end                     type 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val iter : 'a t -> f:('-> unit) -> unit                     val fold :                       'a t ->                       init:'accum -> f:('accum -> '-> 'accum) -> 'accum                     val exists : 'a t -> f:('-> bool) -> bool                     val for_all : 'a t -> f:('-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       'a t -> f:('-> 'sum) -> 'sum                     val find : 'a t -> f:('-> bool) -> 'a option                     val find_map : 'a t -> f:('-> 'b option) -> 'b option                     val to_list : 'a t -> 'a list                     val to_array : 'a t -> 'a array                     val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val invariant : 'a t -> unit                     val create :                       ?growth_allowed:bool -> ?size:int -> unit -> 'a t                     val clear : 'a t -> unit                     val mem : 'a t -> Key.t -> bool                     val lookup : 'a t -> Key.t -> 'a option                     val lookup_exn : 'a t -> Key.t -> 'a                     val enqueue :                       'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]                     val enqueue_exn : 'a t -> Key.t -> '-> unit                     val first : 'a t -> 'a option                     val first_with_key : 'a t -> (Key.t * 'a) option                     val keys : 'a t -> Key.t list                     val dequeue : 'a t -> 'a option                     val dequeue_exn : 'a t -> 'a                     val dequeue_with_key : 'a t -> (Key.t * 'a) option                     val dequeue_with_key_exn : 'a t -> Key.t * 'a                     val dequeue_all : 'a t -> f:('-> unit) -> unit                     val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]                     val remove_exn : 'a t -> Key.t -> unit                     val replace :                       'a t -> Key.t -> '-> [ `No_such_key | `Ok ]                     val replace_exn : 'a t -> Key.t -> '-> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val foldi :                       'a t ->                       init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b                   end                 val to_string : t -> string                 val str : unit -> t -> string                 val pps : unit -> t -> string                 val ppo : Core_kernel.Std.out_channel -> t -> unit                 val pp_seq :                   Format.formatter -> t Core_kernel.Std.Sequence.t -> unit                 val pp : Format.formatter -> t -> unit               end           module Filtered :             functor               (G : Graph) (P : sig                                  type edge = G.edge                                  type node = G.node                                  val edge : edge -> bool                                  val node : node -> bool                                end->               sig                 type t = G.t                 type node = P.node                 type edge = P.edge                 module Node :                   sig                     type t = node                     type graph = G.t                     type label = G.Node.label                     type edge = P.edge                     val create : label -> t                     val label : t -> label                     val mem : t -> graph -> bool                     val succs : t -> graph -> t Regular.Std.seq                     val preds : t -> graph -> t Regular.Std.seq                     val inputs : t -> graph -> edge Regular.Std.seq                     val outputs : t -> graph -> edge Regular.Std.seq                     val degree : ?dir:[ `In | `Out ] -> t -> graph -> int                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val has_edge : t -> t -> graph -> bool                     val edge : t -> t -> graph -> edge option                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness = G.Node.comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = node                             type comparator_witness =                                 G.Node.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (node, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : node -> '-> 'a t                             val of_alist :                               (node * 'a) list ->                               [ `Duplicate_key of node | `Ok of 'a t ]                             val of_alist_or_error :                               (node * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (node * 'a) list -> 'a t                             val of_alist_multi :                               (node * 'a) list -> 'a list t                             val of_alist_fold :                               (node * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (node * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (node * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (node * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:node -> data:'-> 'a t                             val add_multi :                               'a list t -> key:node -> data:'-> 'a list t                             val remove_multi : 'a list t -> node -> 'a list t                             val change :                               'a t ->                               node -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> node -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> node -> 'a option                             val find_exn : 'a t -> node -> 'a                             val remove : 'a t -> node -> 'a t                             val mem : 'a t -> node -> bool                             val iter :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(node -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:node -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(node -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:node -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:node ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:node -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> node list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (node * 'a) list                             val validate :                               name:(node -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:node ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (node, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (node * 'a) option                             val min_elt_exn : 'a t -> node * 'a                             val max_elt : 'a t -> (node * 'a) option                             val max_elt_exn : 'a t -> node * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:node -> data:'-> bool) -> int                             val split :                               'a t ->                               node -> 'a t * (node * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:node ->                               max:node ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:node -> max:node -> (node * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> node -> (node * 'a) option                             val nth : 'a t -> int -> (node * 'a) option                             val rank : 'a t -> node -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:node ->                               ?keys_less_or_equal_to:node ->                               'a t -> (node * 'a) Core_kernel.Sequence.t                             val obs :                               node Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               node Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (node, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : node -> '-> 'a t                         val of_alist :                           (node * 'a) list ->                           [ `Duplicate_key of node | `Ok of 'a t ]                         val of_alist_or_error :                           (node * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (node * 'a) list -> 'a t                         val of_alist_multi : (node * 'a) list -> 'a list t                         val of_alist_fold :                           (node * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (node * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (node * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (node * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:node -> data:'-> 'a t                         val add_multi :                           'a list t -> key:node -> data:'-> 'a list t                         val remove_multi : 'a list t -> node -> 'a list t                         val change :                           'a t -> node -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> node -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> node -> 'a option                         val find_exn : 'a t -> node -> 'a                         val remove : 'a t -> node -> 'a t                         val mem : 'a t -> node -> bool                         val iter :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(node -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:node -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(node -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:node -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:node ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:node -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> node list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (node * 'a) list                         val validate :                           name:(node -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:node ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (node, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (node * 'a) option                         val min_elt_exn : 'a t -> node * 'a                         val max_elt : 'a t -> (node * 'a) option                         val max_elt_exn : 'a t -> node * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:node -> data:'-> bool) -> int                         val split :                           'a t -> node -> 'a t * (node * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:node ->                           max:node ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:node -> max:node -> (node * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> node -> (node * 'a) option                         val nth : 'a t -> int -> (node * 'a) option                         val rank : 'a t -> node -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:node ->                           ?keys_less_or_equal_to:node ->                           'a t -> (node * 'a) Core_kernel.Sequence.t                         val obs :                           node Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           node Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (node, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(node -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> node -> 'accum) -> 'accum                             val exists : t -> f:(node -> bool) -> bool                             val for_all : t -> f:(node -> bool) -> bool                             val count : t -> f:(node -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(node -> 'sum) -> 'sum                             val find : t -> f:(node -> bool) -> node option                             val find_map :                               t -> f:(node -> 'a option) -> 'a option                             val to_list : t -> node list                             val to_array : t -> node array                             val invariants : t -> bool                             val mem : t -> node -> bool                             val add : t -> node -> t                             val remove : t -> node -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (node, node) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  node -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(node -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of node * node                                  | `Left of node                                  | `Right of node ] -> unit) ->                               unit                             val filter : t -> f:(node -> bool) -> t                             val partition_tf : t -> f:(node -> bool) -> t * t                             val elements : t -> node list                             val min_elt : t -> node option                             val min_elt_exn : t -> node                             val max_elt : t -> node option                             val max_elt_exn : t -> node                             val choose : t -> node option                             val choose_exn : t -> node                             val split : t -> node -> t * node option * t                             val group_by :                               t -> equiv:(node -> node -> bool) -> t list                             val find_exn : t -> f:(node -> bool) -> node                             val find_index : t -> int -> node option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t -> node Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t ->                               t ->                               node                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(node -> 'data) ->                               (node, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               node Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               node Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : node -> t                             val union_list : t list -> t                             val of_list : node list -> t                             val of_array : node array -> t                             val of_sorted_array :                               node array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : node array -> t                             val stable_dedup_list : node list -> node list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (node, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (node, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(node -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> node -> 'accum) -> 'accum                         val exists : t -> f:(node -> bool) -> bool                         val for_all : t -> f:(node -> bool) -> bool                         val count : t -> f:(node -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(node -> 'sum) -> 'sum                         val find : t -> f:(node -> bool) -> node option                         val find_map :                           t -> f:(node -> 'a option) -> 'a option                         val to_list : t -> node list                         val to_array : t -> node array                         val invariants : t -> bool                         val mem : t -> node -> bool                         val add : t -> node -> t                         val remove : t -> node -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (node, node) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> node -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(node -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of node * node                              | `Left of node                              | `Right of node ] -> unit) ->                           unit                         val filter : t -> f:(node -> bool) -> t                         val partition_tf : t -> f:(node -> bool) -> t * t                         val elements : t -> node list                         val min_elt : t -> node option                         val min_elt_exn : t -> node                         val max_elt : t -> node option                         val max_elt_exn : t -> node                         val choose : t -> node option                         val choose_exn : t -> node                         val split : t -> node -> t * node option * t                         val group_by :                           t -> equiv:(node -> node -> bool) -> t list                         val find_exn : t -> f:(node -> bool) -> node                         val find_index : t -> int -> node option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t -> node Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t ->                           t ->                           node                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(node -> 'data) ->                           (node, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           node Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           node Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : node -> t                         val union_list : t list -> t                         val of_list : node list -> t                         val of_array : node array -> t                         val of_sorted_array :                           node array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : node array -> t                         val stable_dedup_list : node list -> node list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (node, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) G.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action =                           'G.Node.Table.merge_into_action =                             Remove                           | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'G.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t = 'G.Node.Hash_queue.t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> node -> bool                         val lookup : 'a t -> node -> 'a option                         val lookup_exn : 'a t -> node -> 'a                         val enqueue :                           'a t ->                           node -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> node -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (node * 'a) option                         val keys : 'a t -> node list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (node * 'a) option                         val dequeue_with_key_exn : 'a t -> node * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> node -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> node -> unit                         val replace :                           'a t -> node -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> node -> '-> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:node -> data:'-> 'b) -> 'b                       end                   end                 module Edge :                   sig                     type t = edge                     type node = Node.t                     type graph = Node.graph                     type label = G.Edge.label                     val create : node -> node -> label -> t                     val label : t -> label                     val src : t -> node                     val dst : t -> node                     val mem : t -> graph -> bool                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness = G.Edge.comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = edge                             type comparator_witness =                                 G.Edge.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (edge, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : edge -> '-> 'a t                             val of_alist :                               (edge * 'a) list ->                               [ `Duplicate_key of edge | `Ok of 'a t ]                             val of_alist_or_error :                               (edge * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (edge * 'a) list -> 'a t                             val of_alist_multi :                               (edge * 'a) list -> 'a list t                             val of_alist_fold :                               (edge * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (edge * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (edge * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:edge -> data:'-> 'a t                             val add_multi :                               'a list t -> key:edge -> data:'-> 'a list t                             val remove_multi : 'a list t -> edge -> 'a list t                             val change :                               'a t ->                               edge -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> edge -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> edge -> 'a option                             val find_exn : 'a t -> edge -> 'a                             val remove : 'a t -> edge -> 'a t                             val mem : 'a t -> edge -> bool                             val iter :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(edge -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(edge -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:edge -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:edge ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:edge -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> edge list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (edge * 'a) list                             val validate :                               name:(edge -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:edge ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (edge, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (edge * 'a) option                             val min_elt_exn : 'a t -> edge * 'a                             val max_elt : 'a t -> (edge * 'a) option                             val max_elt_exn : 'a t -> edge * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:edge -> data:'-> bool) -> int                             val split :                               'a t ->                               edge -> 'a t * (edge * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:edge ->                               max:edge ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:edge -> max:edge -> (edge * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> edge -> (edge * 'a) option                             val nth : 'a t -> int -> (edge * 'a) option                             val rank : 'a t -> edge -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:edge ->                               ?keys_less_or_equal_to:edge ->                               'a t -> (edge * 'a) Core_kernel.Sequence.t                             val obs :                               edge Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               edge Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (edge, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : edge -> '-> 'a t                         val of_alist :                           (edge * 'a) list ->                           [ `Duplicate_key of edge | `Ok of 'a t ]                         val of_alist_or_error :                           (edge * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (edge * 'a) list -> 'a t                         val of_alist_multi : (edge * 'a) list -> 'a list t                         val of_alist_fold :                           (edge * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (edge * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (edge * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:edge -> data:'-> 'a t                         val add_multi :                           'a list t -> key:edge -> data:'-> 'a list t                         val remove_multi : 'a list t -> edge -> 'a list t                         val change :                           'a t -> edge -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> edge -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> edge -> 'a option                         val find_exn : 'a t -> edge -> 'a                         val remove : 'a t -> edge -> 'a t                         val mem : 'a t -> edge -> bool                         val iter :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(edge -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:edge -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:edge ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:edge -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> edge list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (edge * 'a) list                         val validate :                           name:(edge -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:edge ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (edge, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (edge * 'a) option                         val min_elt_exn : 'a t -> edge * 'a                         val max_elt : 'a t -> (edge * 'a) option                         val max_elt_exn : 'a t -> edge * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:edge -> data:'-> bool) -> int                         val split :                           'a t -> edge -> 'a t * (edge * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:edge ->                           max:edge ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:edge -> max:edge -> (edge * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> edge -> (edge * 'a) option                         val nth : 'a t -> int -> (edge * 'a) option                         val rank : 'a t -> edge -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:edge ->                           ?keys_less_or_equal_to:edge ->                           'a t -> (edge * 'a) Core_kernel.Sequence.t                         val obs :                           edge Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           edge Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (edge, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(edge -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> edge -> 'accum) -> 'accum                             val exists : t -> f:(edge -> bool) -> bool                             val for_all : t -> f:(edge -> bool) -> bool                             val count : t -> f:(edge -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(edge -> 'sum) -> 'sum                             val find : t -> f:(edge -> bool) -> edge option                             val find_map :                               t -> f:(edge -> 'a option) -> 'a option                             val to_list : t -> edge list                             val to_array : t -> edge array                             val invariants : t -> bool                             val mem : t -> edge -> bool                             val add : t -> edge -> t                             val remove : t -> edge -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (edge, edge) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  edge -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(edge -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of edge * edge                                  | `Left of edge                                  | `Right of edge ] -> unit) ->                               unit                             val filter : t -> f:(edge -> bool) -> t                             val partition_tf : t -> f:(edge -> bool) -> t * t                             val elements : t -> edge list                             val min_elt : t -> edge option                             val min_elt_exn : t -> edge                             val max_elt : t -> edge option                             val max_elt_exn : t -> edge                             val choose : t -> edge option                             val choose_exn : t -> edge                             val split : t -> edge -> t * edge option * t                             val group_by :                               t -> equiv:(edge -> edge -> bool) -> t list                             val find_exn : t -> f:(edge -> bool) -> edge                             val find_index : t -> int -> edge option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t -> edge Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t ->                               t ->                               edge                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(edge -> 'data) ->                               (edge, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               edge Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               edge Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : edge -> t                             val union_list : t list -> t                             val of_list : edge list -> t                             val of_array : edge array -> t                             val of_sorted_array :                               edge array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : edge array -> t                             val stable_dedup_list : edge list -> edge list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (edge, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (edge, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(edge -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> edge -> 'accum) -> 'accum                         val exists : t -> f:(edge -> bool) -> bool                         val for_all : t -> f:(edge -> bool) -> bool                         val count : t -> f:(edge -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(edge -> 'sum) -> 'sum                         val find : t -> f:(edge -> bool) -> edge option                         val find_map :                           t -> f:(edge -> 'a option) -> 'a option                         val to_list : t -> edge list                         val to_array : t -> edge array                         val invariants : t -> bool                         val mem : t -> edge -> bool                         val add : t -> edge -> t                         val remove : t -> edge -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (edge, edge) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> edge -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(edge -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of edge * edge                              | `Left of edge                              | `Right of edge ] -> unit) ->                           unit                         val filter : t -> f:(edge -> bool) -> t                         val partition_tf : t -> f:(edge -> bool) -> t * t                         val elements : t -> edge list                         val min_elt : t -> edge option                         val min_elt_exn : t -> edge                         val max_elt : t -> edge option                         val max_elt_exn : t -> edge                         val choose : t -> edge option                         val choose_exn : t -> edge                         val split : t -> edge -> t * edge option * t                         val group_by :                           t -> equiv:(edge -> edge -> bool) -> t list                         val find_exn : t -> f:(edge -> bool) -> edge                         val find_index : t -> int -> edge option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t -> edge Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t ->                           t ->                           edge                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(edge -> 'data) ->                           (edge, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           edge Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           edge Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : edge -> t                         val union_list : t list -> t                         val of_list : edge list -> t                         val of_array : edge array -> t                         val of_sorted_array :                           edge array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : edge array -> t                         val stable_dedup_list : edge list -> edge list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (edge, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action =                           'G.Edge.Table.merge_into_action =                             Remove                           | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Node.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t = 'G.Edge.Hash_queue.t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> edge -> bool                         val lookup : 'a t -> edge -> 'a option                         val lookup_exn : 'a t -> edge -> 'a                         val enqueue :                           'a t ->                           edge -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> edge -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (edge * 'a) option                         val keys : 'a t -> edge list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (edge * 'a) option                         val dequeue_with_key_exn : 'a t -> edge * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> edge -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> edge -> unit                         val replace :                           'a t -> edge -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> edge -> '-> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:edge -> data:'-> 'b) -> 'b                       end                   end                 val empty : t                 val nodes : t -> node Regular.Std.seq                 val edges : t -> edge Regular.Std.seq                 val is_directed : bool                 val number_of_edges : t -> int                 val number_of_nodes : t -> int                 val ( >= ) : t -> t -> bool                 val ( <= ) : t -> t -> bool                 val ( = ) : t -> t -> bool                 val ( > ) : t -> t -> bool                 val ( < ) : t -> t -> bool                 val ( <> ) : t -> t -> bool                 val equal : t -> t -> bool                 val min : t -> t -> t                 val max : t -> t -> t                 val ascending : t -> t -> int                 val descending : t -> t -> int                 val between : t -> low:t -> high:t -> bool                 val clamp_exn : t -> min:t -> max:t -> t                 val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t                 module Replace_polymorphic_compare :                   sig                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val compare : t -> t -> int                     val min : t -> t -> t                     val max : t -> t -> t                   end                 type comparator_witness                 val comparator :                   (t, comparator_witness) Core_kernel.Comparator.comparator                 val validate_lbound :                   min:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_ubound :                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_bound :                   min:t Core_kernel.Maybe_bound.t ->                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 module Map :                   sig                     module Key :                       sig                         type t = Edge.graph                         type comparator_witness = comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type 'a t =                             (Key.t, 'a, comparator_witness)                             Core_kernel.Core_map.Tree.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val empty : 'a t                         val singleton : Key.t -> '-> 'a t                         val of_alist :                           (Key.t * 'a) list ->                           [ `Duplicate_key of Key.t | `Ok of 'a t ]                         val of_alist_or_error :                           (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (Key.t * 'a) list -> 'a t                         val of_alist_multi : (Key.t * 'a) list -> 'a list t                         val of_alist_fold :                           (Key.t * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (Key.t * 'a) array -> 'a t                         val of_tree : 'a t -> 'a t                         val gen :                           Key.t Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:Key.t -> data:'-> 'a t                         val add_multi :                           'a list t -> key:Key.t -> data:'-> 'a list t                         val remove_multi : 'a list t -> Key.t -> 'a list t                         val change :                           'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> Key.t -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> Key.t -> 'a option                         val find_exn : 'a t -> Key.t -> 'a                         val remove : 'a t -> Key.t -> 'a t                         val mem : 'a t -> Key.t -> bool                         val iter :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:Key.t -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:Key.t ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> Key.t list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (Key.t * 'a) list                         val validate :                           name:(Key.t -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (Key.t, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (Key.t * 'a) option                         val min_elt_exn : 'a t -> Key.t * 'a                         val max_elt : 'a t -> (Key.t * 'a) option                         val max_elt_exn : 'a t -> Key.t * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:Key.t -> data:'-> bool) -> int                         val split :                           'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:Key.t ->                           max:Key.t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> Key.t -> (Key.t * 'a) option                         val nth : 'a t -> int -> (Key.t * 'a) option                         val rank : 'a t -> Key.t -> int option                         val to_tree : 'a t -> 'a t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:Key.t ->                           ?keys_less_or_equal_to:Key.t ->                           'a t -> (Key.t * 'a) Core_kernel.Sequence.t                         val obs :                           Key.t Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           Key.t Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     type 'a t =                         (Key.t, 'a, comparator_witness)                         Core_kernel.Core_map.t                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val compare : ('-> '-> int) -> 'a t -> 'a t -> int                     val empty : 'a t                     val singleton : Key.t -> '-> 'a t                     val of_alist :                       (Key.t * 'a) list ->                       [ `Duplicate_key of Key.t | `Ok of 'a t ]                     val of_alist_or_error :                       (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                     val of_alist_exn : (Key.t * 'a) list -> 'a t                     val of_alist_multi : (Key.t * 'a) list -> 'a list t                     val of_alist_fold :                       (Key.t * 'a) list ->                       init:'-> f:('-> '-> 'b) -> 'b t                     val of_alist_reduce :                       (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                     val of_sorted_array :                       (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                     val of_sorted_array_unchecked :                       (Key.t * 'a) array -> 'a t                     val of_tree : 'Tree.t -> 'a t                     val gen :                       Key.t Core_kernel.Quickcheck.Generator.t ->                       'Core_kernel.Quickcheck.Generator.t ->                       'a t Core_kernel.Quickcheck.Generator.t                     val invariants : 'a t -> bool                     val is_empty : 'a t -> bool                     val length : 'a t -> int                     val add : 'a t -> key:Key.t -> data:'-> 'a t                     val add_multi :                       'a list t -> key:Key.t -> data:'-> 'a list t                     val remove_multi : 'a list t -> Key.t -> 'a list t                     val change :                       'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                     val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                     val find : 'a t -> Key.t -> 'a option                     val find_exn : 'a t -> Key.t -> 'a                     val remove : 'a t -> Key.t -> 'a t                     val mem : 'a t -> Key.t -> bool                     val iter :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                     val iter2 :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          unit) ->                       unit                     val map : 'a t -> f:('-> 'b) -> 'b t                     val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                     val fold :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold_right :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold2 :                       'a t ->                       'b t ->                       init:'->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          '-> 'c) ->                       'c                     val filter :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filteri :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                     val filter_map : 'a t -> f:('-> 'b option) -> 'b t                     val filter_mapi :                       'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                     val partition_mapi :                       'a t ->                       f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                       'b t * 'c t                     val partition_map :                       'a t ->                       f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                     val partitioni_tf :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                     val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                     val compare_direct :                       ('-> '-> int) -> 'a t -> 'a t -> int                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                     val keys : 'a t -> Key.t list                     val data : 'a t -> 'a list                     val to_alist :                       ?key_order:[ `Decreasing | `Increasing ] ->                       'a t -> (Key.t * 'a) list                     val validate :                       name:(Key.t -> string) ->                       'Core_kernel.Validate.check ->                       'a t Core_kernel.Validate.check                     val merge :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          'c option) ->                       'c t                     val symmetric_diff :                       'a t ->                       'a t ->                       data_equal:('-> '-> bool) ->                       (Key.t, 'a)                       Core_kernel.Core_map_intf.Symmetric_diff_element.t                       Core_kernel.Sequence.t                     val min_elt : 'a t -> (Key.t * 'a) option                     val min_elt_exn : 'a t -> Key.t * 'a                     val max_elt : 'a t -> (Key.t * 'a) option                     val max_elt_exn : 'a t -> Key.t * 'a                     val for_all : 'a t -> f:('-> bool) -> bool                     val for_alli :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val exists : 'a t -> f:('-> bool) -> bool                     val existsi :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val counti :                       'a t -> f:(key:Key.t -> data:'-> bool) -> int                     val split :                       'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                     val fold_range_inclusive :                       'a t ->                       min:Key.t ->                       max:Key.t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val range_to_alist :                       'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                     val closest_key :                       'a t ->                       [ `Greater_or_equal_to                       | `Greater_than                       | `Less_or_equal_to                       | `Less_than ] -> Key.t -> (Key.t * 'a) option                     val nth : 'a t -> int -> (Key.t * 'a) option                     val rank : 'a t -> Key.t -> int option                     val to_tree : 'a t -> 'Tree.t                     val to_sequence :                       ?order:[ `Decreasing_key | `Increasing_key ] ->                       ?keys_greater_or_equal_to:Key.t ->                       ?keys_less_or_equal_to:Key.t ->                       'a t -> (Key.t * 'a) Core_kernel.Sequence.t                     val obs :                       Key.t Core_kernel.Quickcheck.Observer.t ->                       'Core_kernel.Quickcheck.Observer.t ->                       'v t Core_kernel.Quickcheck.Observer.t                     val shrinker :                       Key.t Core_kernel.Quickcheck.Shrinker.t ->                       'Core_kernel.Quickcheck.Shrinker.t ->                       'v t Core_kernel.Quickcheck.Shrinker.t                   end                 module Set :                   sig                     module Elt :                       sig                         type t = Edge.graph                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type comparator_witness = Map.Key.comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type t =                             (Elt.t, comparator_witness)                             Core_kernel.Core_set.Tree.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(Elt.t -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> Elt.t -> 'accum) -> 'accum                         val exists : t -> f:(Elt.t -> bool) -> bool                         val for_all : t -> f:(Elt.t -> bool) -> bool                         val count : t -> f:(Elt.t -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(Elt.t -> 'sum) -> 'sum                         val find : t -> f:(Elt.t -> bool) -> Elt.t option                         val find_map :                           t -> f:(Elt.t -> 'a option) -> 'a option                         val to_list : t -> Elt.t list                         val to_array : t -> Elt.t array                         val invariants : t -> bool                         val mem : t -> Elt.t -> bool                         val add : t -> Elt.t -> t                         val remove : t -> Elt.t -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (Elt.t, Elt.t) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of Elt.t * Elt.t                              | `Left of Elt.t                              | `Right of Elt.t ] -> unit) ->                           unit                         val filter : t -> f:(Elt.t -> bool) -> t                         val partition_tf : t -> f:(Elt.t -> bool) -> t * t                         val elements : t -> Elt.t list                         val min_elt : t -> Elt.t option                         val min_elt_exn : t -> Elt.t                         val max_elt : t -> Elt.t option                         val max_elt_exn : t -> Elt.t                         val choose : t -> Elt.t option                         val choose_exn : t -> Elt.t                         val split : t -> Elt.t -> t * Elt.t option * t                         val group_by :                           t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                         val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                         val find_index : t -> int -> Elt.t option                         val remove_index : t -> int -> t                         val to_tree : t -> t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t -> Elt.t Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t ->                           t ->                           Elt.t                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(Elt.t -> 'data) ->                           (Elt.t, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           Elt.t Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           Elt.t Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : Elt.t -> t                         val union_list : t list -> t                         val of_list : Elt.t list -> t                         val of_array : Elt.t array -> t                         val of_sorted_array :                           Elt.t array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : Elt.t array -> t                         val stable_dedup_list : Elt.t list -> Elt.t list                         val map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t option) -> t                         val of_tree : t -> t                         val of_map_keys :                           (Elt.t, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           Elt.t Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     type t =                         (Elt.t, comparator_witness) Core_kernel.Core_set.t                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     val compare : t -> t -> int                     val length : t -> int                     val is_empty : t -> bool                     val iter : t -> f:(Elt.t -> unit) -> unit                     val fold :                       t ->                       init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                     val exists : t -> f:(Elt.t -> bool) -> bool                     val for_all : t -> f:(Elt.t -> bool) -> bool                     val count : t -> f:(Elt.t -> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       t -> f:(Elt.t -> 'sum) -> 'sum                     val find : t -> f:(Elt.t -> bool) -> Elt.t option                     val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                     val to_list : t -> Elt.t list                     val to_array : t -> Elt.t array                     val invariants : t -> bool                     val mem : t -> Elt.t -> bool                     val add : t -> Elt.t -> t                     val remove : t -> Elt.t -> t                     val union : t -> t -> t                     val inter : t -> t -> t                     val diff : t -> t -> t                     val symmetric_diff :                       t ->                       t ->                       (Elt.t, Elt.t) Core_kernel.Either.t                       Core_kernel.Sequence.t                     val compare_direct : t -> t -> int                     val equal : t -> t -> bool                     val subset : t -> t -> bool                     val fold_until :                       t ->                       init:'->                       f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                       'b                     val fold_right :                       t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                     val iter2 :                       t ->                       t ->                       f:([ `Both of Elt.t * Elt.t                          | `Left of Elt.t                          | `Right of Elt.t ] -> unit) ->                       unit                     val filter : t -> f:(Elt.t -> bool) -> t                     val partition_tf : t -> f:(Elt.t -> bool) -> t * t                     val elements : t -> Elt.t list                     val min_elt : t -> Elt.t option                     val min_elt_exn : t -> Elt.t                     val max_elt : t -> Elt.t option                     val max_elt_exn : t -> Elt.t                     val choose : t -> Elt.t option                     val choose_exn : t -> Elt.t                     val split : t -> Elt.t -> t * Elt.t option * t                     val group_by :                       t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                     val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                     val find_index : t -> int -> Elt.t option                     val remove_index : t -> int -> t                     val to_tree : t -> Tree.t                     val to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t -> Elt.t Core_kernel.Sequence.t                     val merge_to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t ->                       t ->                       Elt.t                       Core_kernel.Core_set_intf.Merge_to_sequence_element.t                       Core_kernel.Sequence.t                     val to_map :                       t ->                       f:(Elt.t -> 'data) ->                       (Elt.t, 'data, comparator_witness)                       Core_kernel.Core_set_intf.Map.t                     val obs :                       Elt.t Core_kernel.Quickcheck.obs ->                       t Core_kernel.Quickcheck.obs                     val shrinker :                       Elt.t Core_kernel.Quickcheck.shr ->                       t Core_kernel.Quickcheck.shr                     val empty : t                     val singleton : Elt.t -> t                     val union_list : t list -> t                     val of_list : Elt.t list -> t                     val of_array : Elt.t array -> t                     val of_sorted_array :                       Elt.t array -> t Core_kernel.Or_error.t                     val of_sorted_array_unchecked : Elt.t array -> t                     val stable_dedup_list : Elt.t list -> Elt.t list                     val map :                       ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t                     val filter_map :                       ('a, 'b) Core_kernel.Core_set.t ->                       f:('-> Elt.t option) -> t                     val of_tree : Tree.t -> t                     val of_map_keys :                       (Elt.t, 'a, comparator_witness)                       Core_kernel.Core_set_intf.Map.t -> t                     val gen :                       Elt.t Core_kernel.Quickcheck.Generator.t ->                       t Core_kernel.Quickcheck.Generator.t                   end                 val hash : t -> int                 val compare : t -> t -> int                 val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                 module Table :                   sig                     type key = t                     type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl                     type 'b t = (key, 'b) hashtbl                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                     type ('a, 'b) t_ = 'b t                     type 'a key_ = key                     val hashable :                       key Core_kernel.Core_hashtbl_intf.Hashable.t                     val invariant :                       'Core_kernel.Invariant_intf.inv ->                       'a t Core_kernel.Invariant_intf.inv                     val create :                       (key, 'b, unit -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_key of key | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_report_all_dups :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_or_error :                       (key, 'b,                        (key * 'b) list -> 'b t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_exn :                       (key, 'b, (key * 'b) list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_multi :                       (key, 'b list, (key * 'b) list -> 'b list t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_mapped :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key :                       (key, 'r,                        get_key:('-> key) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'r t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_or_error :                       (key, 'r,                        get_key:('-> key) ->                        'r list -> 'r t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_exn :                       (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val group :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        combine:('-> '-> 'b) -> 'r list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                     val clear : 'a t -> unit                     val copy : 'b t -> 'b t                     val fold :                       'b t ->                       init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                     val iter_vals : 'b t -> f:('-> unit) -> unit                     val iteri :                       'b t -> f:(key:key -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(key -> unit) -> unit                     val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                     val existsi :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val exists : 'b t -> f:('-> bool) -> bool                     val for_alli :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val for_all : 'b t -> f:('-> bool) -> bool                     val counti :                       'b t -> f:(key:key -> data:'-> bool) -> int                     val count : 'b t -> f:('-> bool) -> int                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val mem : 'a t -> key -> bool                     val remove : 'a t -> key -> unit                     val replace : 'b t -> key:key -> data:'-> unit                     val set : 'b t -> key:key -> data:'-> unit                     val add :                       'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                     val add_or_error :                       'b t ->                       key:key -> data:'-> unit Core_kernel.Or_error.t                     val add_exn : 'b t -> key:key -> data:'-> unit                     val change :                       'b t -> key -> f:('b option -> 'b option) -> unit                     val update : 'b t -> key -> f:('b option -> 'b) -> unit                     val add_multi : 'b list t -> key:key -> data:'-> unit                     val remove_multi : 'a list t -> key -> unit                     val map :                       ('c, 'b t -> f:('-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val mapi :                       ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_map :                       ('c, 'b t -> f:('-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_mapi :                       ('c,                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter : 'b t -> f:('-> bool) -> 'b t                     val filteri :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t                     val partition_map :                       ('c,                        ('d,                         'b t ->                         f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_mapi :                       ('c,                        ('d,                         'b t ->                         f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                         'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                     val partitioni_tf :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                     val find_or_add :                       'b t -> key -> default:(unit -> 'b) -> 'b                     val find : 'b t -> key -> 'b option                     val find_exn : 'b t -> key -> 'b                     val find_and_call :                       'b t ->                       key ->                       if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                     val find_and_remove : 'b t -> key -> 'b option                     val merge :                       ('c,                        'a t ->                        'b t ->                        f:(key:key ->                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                           'c option) ->                        'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     type 'a merge_into_action = Remove | Set_to of 'a                     val merge_into :                       src:'a t ->                       dst:'b t ->                       f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                       unit                     val keys : 'a t -> key list                     val data : 'b t -> 'b list                     val filter_inplace : 'b t -> f:('-> bool) -> unit                     val filteri_inplace :                       'b t -> f:(key:key -> data:'-> bool) -> unit                     val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                     val map_inplace : 'b t -> f:('-> 'b) -> unit                     val mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_map_inplace :                       'b t -> f:('-> 'b option) -> unit                     val filter_mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val replace_all : 'b t -> f:('-> 'b) -> unit                     val replace_alli :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_replace_all :                       'b t -> f:('-> 'b option) -> unit                     val filter_replace_alli :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                     val similar :                       'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                     val to_alist : 'b t -> (key * 'b) list                     val validate :                       name:(key -> string) ->                       'Core_kernel.Validate.check ->                       'b t Core_kernel.Validate.check                     val incr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                     val decr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   end                 module Hash_set :                   sig                     type elt = t                     type 'a hash_set = 'Edge.Hash_set.hash_set                     type t = elt hash_set                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     type 'a t_ = t                     type 'a elt_ = elt                     val create :                       ('a, unit -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                     val of_list :                       ('a, elt list -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                   end                 module Hash_queue :                   sig                     module Key :                       sig                         type t = Hash_set.elt                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val hash : t -> int                       end                     type 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val iter : 'a t -> f:('-> unit) -> unit                     val fold :                       'a t ->                       init:'accum -> f:('accum -> '-> 'accum) -> 'accum                     val exists : 'a t -> f:('-> bool) -> bool                     val for_all : 'a t -> f:('-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       'a t -> f:('-> 'sum) -> 'sum                     val find : 'a t -> f:('-> bool) -> 'a option                     val find_map : 'a t -> f:('-> 'b option) -> 'b option                     val to_list : 'a t -> 'a list                     val to_array : 'a t -> 'a array                     val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val invariant : 'a t -> unit                     val create :                       ?growth_allowed:bool -> ?size:int -> unit -> 'a t                     val clear : 'a t -> unit                     val mem : 'a t -> Key.t -> bool                     val lookup : 'a t -> Key.t -> 'a option                     val lookup_exn : 'a t -> Key.t -> 'a                     val enqueue :                       'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]                     val enqueue_exn : 'a t -> Key.t -> '-> unit                     val first : 'a t -> 'a option                     val first_with_key : 'a t -> (Key.t * 'a) option                     val keys : 'a t -> Key.t list                     val dequeue : 'a t -> 'a option                     val dequeue_exn : 'a t -> 'a                     val dequeue_with_key : 'a t -> (Key.t * 'a) option                     val dequeue_with_key_exn : 'a t -> Key.t * 'a                     val dequeue_all : 'a t -> f:('-> unit) -> unit                     val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]                     val remove_exn : 'a t -> Key.t -> unit                     val replace :                       'a t -> Key.t -> '-> [ `No_such_key | `Ok ]                     val replace_exn : 'a t -> Key.t -> '-> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val foldi :                       'a t ->                       init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b                   end                 val to_string : t -> string                 val str : unit -> t -> string                 val pps : unit -> t -> string                 val ppo : Core_kernel.Std.out_channel -> t -> unit                 val pp_seq :                   Format.formatter -> t Core_kernel.Std.Sequence.t -> unit                 val pp : Format.formatter -> t -> unit               end           module Mapper :             functor               (G : Graph) (N : sig                                  type s = G.node                                  type t                                  val forward : s -> t                                  val backward : t -> s                                end) (E : sig                                            type s = G.edge                                            type t                                            val forward : s -> t                                            val backward : t -> s                                          end) (NL : sig                                                       type s = G.Node.label                                                       type t                                                       val forward : s -> t                                                       val backward : t -> s                                                     end) (EL : sig                                                                  type s =                                                                     G.Edge.label                                                                  type t                                                                  val forward :                                                                    s -> t                                                                  val backward :                                                                    t -> s                                                                end->               sig                 type t = G.t                 type node = N.t                 type edge = E.t                 module Node :                   sig                     type t = node                     type graph = G.t                     type label = NL.t                     type edge = E.t                     val create : label -> t                     val label : t -> label                     val mem : t -> graph -> bool                     val succs : t -> graph -> t Regular.Std.seq                     val preds : t -> graph -> t Regular.Std.seq                     val inputs : t -> graph -> edge Regular.Std.seq                     val outputs : t -> graph -> edge Regular.Std.seq                     val degree : ?dir:[ `In | `Out ] -> t -> graph -> int                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val has_edge : t -> t -> graph -> bool                     val edge : t -> t -> graph -> edge option                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = node                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (node, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : node -> '-> 'a t                             val of_alist :                               (node * 'a) list ->                               [ `Duplicate_key of node | `Ok of 'a t ]                             val of_alist_or_error :                               (node * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (node * 'a) list -> 'a t                             val of_alist_multi :                               (node * 'a) list -> 'a list t                             val of_alist_fold :                               (node * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (node * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (node * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (node * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:node -> data:'-> 'a t                             val add_multi :                               'a list t -> key:node -> data:'-> 'a list t                             val remove_multi : 'a list t -> node -> 'a list t                             val change :                               'a t ->                               node -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> node -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> node -> 'a option                             val find_exn : 'a t -> node -> 'a                             val remove : 'a t -> node -> 'a t                             val mem : 'a t -> node -> bool                             val iter :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:node -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(node -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:node -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:node ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:node -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(node -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:node -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:node ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:node -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> node list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (node * 'a) list                             val validate :                               name:(node -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:node ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (node, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (node * 'a) option                             val min_elt_exn : 'a t -> node * 'a                             val max_elt : 'a t -> (node * 'a) option                             val max_elt_exn : 'a t -> node * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:node -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:node -> data:'-> bool) -> int                             val split :                               'a t ->                               node -> 'a t * (node * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:node ->                               max:node ->                               init:'->                               f:(key:node -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:node -> max:node -> (node * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> node -> (node * 'a) option                             val nth : 'a t -> int -> (node * 'a) option                             val rank : 'a t -> node -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:node ->                               ?keys_less_or_equal_to:node ->                               'a t -> (node * 'a) Core_kernel.Sequence.t                             val obs :                               node Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               node Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (node, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : node -> '-> 'a t                         val of_alist :                           (node * 'a) list ->                           [ `Duplicate_key of node | `Ok of 'a t ]                         val of_alist_or_error :                           (node * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (node * 'a) list -> 'a t                         val of_alist_multi : (node * 'a) list -> 'a list t                         val of_alist_fold :                           (node * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (node * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (node * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (node * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:node -> data:'-> 'a t                         val add_multi :                           'a list t -> key:node -> data:'-> 'a list t                         val remove_multi : 'a list t -> node -> 'a list t                         val change :                           'a t -> node -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> node -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> node -> 'a option                         val find_exn : 'a t -> node -> 'a                         val remove : 'a t -> node -> 'a t                         val mem : 'a t -> node -> bool                         val iter :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(node -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:node -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:node ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:node -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(node -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:node -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:node ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:node -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> node list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (node * 'a) list                         val validate :                           name:(node -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:node ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (node, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (node * 'a) option                         val min_elt_exn : 'a t -> node * 'a                         val max_elt : 'a t -> (node * 'a) option                         val max_elt_exn : 'a t -> node * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:node -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:node -> data:'-> bool) -> int                         val split :                           'a t -> node -> 'a t * (node * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:node ->                           max:node ->                           init:'->                           f:(key:node -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:node -> max:node -> (node * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> node -> (node * 'a) option                         val nth : 'a t -> int -> (node * 'a) option                         val rank : 'a t -> node -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:node ->                           ?keys_less_or_equal_to:node ->                           'a t -> (node * 'a) Core_kernel.Sequence.t                         val obs :                           node Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           node Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (node, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(node -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> node -> 'accum) -> 'accum                             val exists : t -> f:(node -> bool) -> bool                             val for_all : t -> f:(node -> bool) -> bool                             val count : t -> f:(node -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(node -> 'sum) -> 'sum                             val find : t -> f:(node -> bool) -> node option                             val find_map :                               t -> f:(node -> 'a option) -> 'a option                             val to_list : t -> node list                             val to_array : t -> node array                             val invariants : t -> bool                             val mem : t -> node -> bool                             val add : t -> node -> t                             val remove : t -> node -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (node, node) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  node -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(node -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of node * node                                  | `Left of node                                  | `Right of node ] -> unit) ->                               unit                             val filter : t -> f:(node -> bool) -> t                             val partition_tf : t -> f:(node -> bool) -> t * t                             val elements : t -> node list                             val min_elt : t -> node option                             val min_elt_exn : t -> node                             val max_elt : t -> node option                             val max_elt_exn : t -> node                             val choose : t -> node option                             val choose_exn : t -> node                             val split : t -> node -> t * node option * t                             val group_by :                               t -> equiv:(node -> node -> bool) -> t list                             val find_exn : t -> f:(node -> bool) -> node                             val find_index : t -> int -> node option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t -> node Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:node ->                               ?less_or_equal_to:node ->                               t ->                               t ->                               node                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(node -> 'data) ->                               (node, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               node Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               node Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : node -> t                             val union_list : t list -> t                             val of_list : node list -> t                             val of_array : node array -> t                             val of_sorted_array :                               node array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : node array -> t                             val stable_dedup_list : node list -> node list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> node option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (node, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               node Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (node, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(node -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> node -> 'accum) -> 'accum                         val exists : t -> f:(node -> bool) -> bool                         val for_all : t -> f:(node -> bool) -> bool                         val count : t -> f:(node -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(node -> 'sum) -> 'sum                         val find : t -> f:(node -> bool) -> node option                         val find_map :                           t -> f:(node -> 'a option) -> 'a option                         val to_list : t -> node list                         val to_array : t -> node array                         val invariants : t -> bool                         val mem : t -> node -> bool                         val add : t -> node -> t                         val remove : t -> node -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (node, node) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> node -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(node -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of node * node                              | `Left of node                              | `Right of node ] -> unit) ->                           unit                         val filter : t -> f:(node -> bool) -> t                         val partition_tf : t -> f:(node -> bool) -> t * t                         val elements : t -> node list                         val min_elt : t -> node option                         val min_elt_exn : t -> node                         val max_elt : t -> node option                         val max_elt_exn : t -> node                         val choose : t -> node option                         val choose_exn : t -> node                         val split : t -> node -> t * node option * t                         val group_by :                           t -> equiv:(node -> node -> bool) -> t list                         val find_exn : t -> f:(node -> bool) -> node                         val find_index : t -> int -> node option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t -> node Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:node ->                           ?less_or_equal_to:node ->                           t ->                           t ->                           node                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(node -> 'data) ->                           (node, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           node Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           node Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : node -> t                         val union_list : t list -> t                         val of_list : node list -> t                         val of_array : node array -> t                         val of_sorted_array :                           node array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : node array -> t                         val stable_dedup_list : node list -> node list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> node option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (node, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           node Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) G.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'G.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = node                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> node -> bool                         val lookup : 'a t -> node -> 'a option                         val lookup_exn : 'a t -> node -> 'a                         val enqueue :                           'a t ->                           node -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> node -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (node * 'a) option                         val keys : 'a t -> node list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (node * 'a) option                         val dequeue_with_key_exn : 'a t -> node * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> node -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> node -> unit                         val replace :                           'a t -> node -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> node -> '-> unit                         val iteri :                           'a t -> f:(key:node -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:node -> data:'-> 'b) -> 'b                       end                   end                 module Edge :                   sig                     type t = edge                     type node = Node.t                     type graph = Node.graph                     type label = EL.t                     val create : node -> node -> label -> t                     val label : t -> label                     val src : t -> node                     val dst : t -> node                     val mem : t -> graph -> bool                     val insert : t -> graph -> graph                     val update : t -> label -> graph -> graph                     val remove : t -> graph -> graph                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val min : t -> t -> t                     val max : t -> t -> t                     val ascending : t -> t -> int                     val descending : t -> t -> int                     val between : t -> low:t -> high:t -> bool                     val clamp_exn : t -> min:t -> max:t -> t                     val clamp :                       t -> min:t -> max:t -> t Core_kernel.Or_error.t                     module Replace_polymorphic_compare :                       sig                         val ( >= ) : t -> t -> bool                         val ( <= ) : t -> t -> bool                         val ( = ) : t -> t -> bool                         val ( > ) : t -> t -> bool                         val ( < ) : t -> t -> bool                         val ( <> ) : t -> t -> bool                         val equal : t -> t -> bool                         val compare : t -> t -> int                         val min : t -> t -> t                         val max : t -> t -> t                       end                     type comparator_witness                     val comparator :                       (t, comparator_witness)                       Core_kernel.Comparator.comparator                     val validate_lbound :                       min:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_ubound :                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     val validate_bound :                       min:t Core_kernel.Maybe_bound.t ->                       max:t Core_kernel.Maybe_bound.t ->                       t Core_kernel.Validate.check                     module Map :                       sig                         module Key :                           sig                             type t = edge                             type comparator_witness = comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type 'a t =                                 (edge, 'a, comparator_witness)                                 Core_kernel.Core_map.Tree.t                             val t_of_sexp :                               (Sexplib.Sexp.t -> 'a) ->                               Sexplib.Sexp.t -> 'a t                             val sexp_of_t :                               ('-> Sexplib.Sexp.t) ->                               'a t -> Sexplib.Sexp.t                             val empty : 'a t                             val singleton : edge -> '-> 'a t                             val of_alist :                               (edge * 'a) list ->                               [ `Duplicate_key of edge | `Ok of 'a t ]                             val of_alist_or_error :                               (edge * 'a) list -> 'a t Core_kernel.Or_error.t                             val of_alist_exn : (edge * 'a) list -> 'a t                             val of_alist_multi :                               (edge * 'a) list -> 'a list t                             val of_alist_fold :                               (edge * 'a) list ->                               init:'-> f:('-> '-> 'b) -> 'b t                             val of_alist_reduce :                               (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                             val of_sorted_array :                               (edge * 'a) array ->                               'a t Core_kernel.Or_error.t                             val of_sorted_array_unchecked :                               (edge * 'a) array -> 'a t                             val of_tree : 'a t -> 'a t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               'Core_kernel.Quickcheck.Generator.t ->                               'a t Core_kernel.Quickcheck.Generator.t                             val invariants : 'a t -> bool                             val is_empty : 'a t -> bool                             val length : 'a t -> int                             val add : 'a t -> key:edge -> data:'-> 'a t                             val add_multi :                               'a list t -> key:edge -> data:'-> 'a list t                             val remove_multi : 'a list t -> edge -> 'a list t                             val change :                               'a t ->                               edge -> f:('a option -> 'a option) -> 'a t                             val update :                               'a t -> edge -> f:('a option -> 'a) -> 'a t                             val find : 'a t -> edge -> 'a option                             val find_exn : 'a t -> edge -> 'a                             val remove : 'a t -> edge -> 'a t                             val mem : 'a t -> edge -> bool                             val iter :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iteri :                               'a t -> f:(key:edge -> data:'-> unit) -> unit                             val iter_keys : 'a t -> f:(edge -> unit) -> unit                             val iter2 :                               'a t ->                               'b t ->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  unit) ->                               unit                             val map : 'a t -> f:('-> 'b) -> 'b t                             val mapi :                               'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                             val fold :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold_right :                               'a t ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val fold2 :                               'a t ->                               'b t ->                               init:'->                               f:(key:edge ->                                  data:[ `Both of 'a * 'b                                       | `Left of 'a                                       | `Right of 'b ] ->                                  '-> 'c) ->                               'c                             val filter :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filteri :                               'a t -> f:(key:edge -> data:'-> bool) -> 'a t                             val filter_keys :                               'a t -> f:(edge -> bool) -> 'a t                             val filter_map :                               'a t -> f:('-> 'b option) -> 'b t                             val filter_mapi :                               'a t ->                               f:(key:edge -> data:'-> 'b option) -> 'b t                             val partition_mapi :                               'a t ->                               f:(key:edge ->                                  data:'-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partition_map :                               'a t ->                               f:('-> [ `Fst of '| `Snd of 'c ]) ->                               'b t * 'c t                             val partitioni_tf :                               'a t ->                               f:(key:edge -> data:'-> bool) -> 'a t * 'a t                             val partition_tf :                               'a t -> f:('-> bool) -> 'a t * 'a t                             val compare_direct :                               ('-> '-> int) -> 'a t -> 'a t -> int                             val equal :                               ('-> '-> bool) -> 'a t -> 'a t -> bool                             val keys : 'a t -> edge list                             val data : 'a t -> 'a list                             val to_alist :                               ?key_order:[ `Decreasing | `Increasing ] ->                               'a t -> (edge * 'a) list                             val validate :                               name:(edge -> string) ->                               'Core_kernel.Validate.check ->                               'a t Core_kernel.Validate.check                             val merge :                               'a t ->                               'b t ->                               f:(key:edge ->                                  [ `Both of 'a * 'b                                  | `Left of 'a                                  | `Right of 'b ] -> 'c option) ->                               'c t                             val symmetric_diff :                               'a t ->                               'a t ->                               data_equal:('-> '-> bool) ->                               (edge, 'a)                               Core_kernel.Core_map_intf.Symmetric_diff_element.t                               Core_kernel.Sequence.t                             val min_elt : 'a t -> (edge * 'a) option                             val min_elt_exn : 'a t -> edge * 'a                             val max_elt : 'a t -> (edge * 'a) option                             val max_elt_exn : 'a t -> edge * 'a                             val for_all : 'a t -> f:('-> bool) -> bool                             val for_alli :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val exists : 'a t -> f:('-> bool) -> bool                             val existsi :                               'a t -> f:(key:edge -> data:'-> bool) -> bool                             val count : 'a t -> f:('-> bool) -> int                             val counti :                               'a t -> f:(key:edge -> data:'-> bool) -> int                             val split :                               'a t ->                               edge -> 'a t * (edge * 'a) option * 'a t                             val fold_range_inclusive :                               'a t ->                               min:edge ->                               max:edge ->                               init:'->                               f:(key:edge -> data:'-> '-> 'b) -> 'b                             val range_to_alist :                               'a t ->                               min:edge -> max:edge -> (edge * 'a) list                             val closest_key :                               'a t ->                               [ `Greater_or_equal_to                               | `Greater_than                               | `Less_or_equal_to                               | `Less_than ] -> edge -> (edge * 'a) option                             val nth : 'a t -> int -> (edge * 'a) option                             val rank : 'a t -> edge -> int option                             val to_tree : 'a t -> 'a t                             val to_sequence :                               ?order:[ `Decreasing_key | `Increasing_key ] ->                               ?keys_greater_or_equal_to:edge ->                               ?keys_less_or_equal_to:edge ->                               'a t -> (edge * 'a) Core_kernel.Sequence.t                             val obs :                               edge Core_kernel.Quickcheck.Observer.t ->                               'Core_kernel.Quickcheck.Observer.t ->                               'v t Core_kernel.Quickcheck.Observer.t                             val shrinker :                               edge Core_kernel.Quickcheck.Shrinker.t ->                               'Core_kernel.Quickcheck.Shrinker.t ->                               'v t Core_kernel.Quickcheck.Shrinker.t                           end                         type 'a t =                             (edge, 'a, comparator_witness)                             Core_kernel.Core_map.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val compare :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val empty : 'a t                         val singleton : edge -> '-> 'a t                         val of_alist :                           (edge * 'a) list ->                           [ `Duplicate_key of edge | `Ok of 'a t ]                         val of_alist_or_error :                           (edge * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (edge * 'a) list -> 'a t                         val of_alist_multi : (edge * 'a) list -> 'a list t                         val of_alist_fold :                           (edge * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (edge * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (edge * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (edge * 'a) array -> 'a t                         val of_tree : 'Tree.t -> 'a t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:edge -> data:'-> 'a t                         val add_multi :                           'a list t -> key:edge -> data:'-> 'a list t                         val remove_multi : 'a list t -> edge -> 'a list t                         val change :                           'a t -> edge -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> edge -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> edge -> 'a option                         val find_exn : 'a t -> edge -> 'a                         val remove : 'a t -> edge -> 'a t                         val mem : 'a t -> edge -> bool                         val iter :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(edge -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:edge -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:edge ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:edge -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(edge -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:edge -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:edge ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:edge -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> edge list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (edge * 'a) list                         val validate :                           name:(edge -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:edge ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (edge, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (edge * 'a) option                         val min_elt_exn : 'a t -> edge * 'a                         val max_elt : 'a t -> (edge * 'a) option                         val max_elt_exn : 'a t -> edge * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:edge -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:edge -> data:'-> bool) -> int                         val split :                           'a t -> edge -> 'a t * (edge * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:edge ->                           max:edge ->                           init:'->                           f:(key:edge -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:edge -> max:edge -> (edge * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> edge -> (edge * 'a) option                         val nth : 'a t -> int -> (edge * 'a) option                         val rank : 'a t -> edge -> int option                         val to_tree : 'a t -> 'Tree.t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:edge ->                           ?keys_less_or_equal_to:edge ->                           'a t -> (edge * 'a) Core_kernel.Sequence.t                         val obs :                           edge Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           edge Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     module Set :                       sig                         module Elt :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             type comparator_witness =                                 Map.Key.comparator_witness                             val comparator :                               (t, comparator_witness)                               Core_kernel.Comparator.comparator                           end                         module Tree :                           sig                             type t =                                 (edge, comparator_witness)                                 Core_kernel.Core_set.Tree.t                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val length : t -> int                             val is_empty : t -> bool                             val iter : t -> f:(edge -> unit) -> unit                             val fold :                               t ->                               init:'accum ->                               f:('accum -> edge -> 'accum) -> 'accum                             val exists : t -> f:(edge -> bool) -> bool                             val for_all : t -> f:(edge -> bool) -> bool                             val count : t -> f:(edge -> bool) -> int                             val sum :                               (module Core_kernel.Commutative_group.S with type t = 'sum) ->                               t -> f:(edge -> 'sum) -> 'sum                             val find : t -> f:(edge -> bool) -> edge option                             val find_map :                               t -> f:(edge -> 'a option) -> 'a option                             val to_list : t -> edge list                             val to_array : t -> edge array                             val invariants : t -> bool                             val mem : t -> edge -> bool                             val add : t -> edge -> t                             val remove : t -> edge -> t                             val union : t -> t -> t                             val inter : t -> t -> t                             val diff : t -> t -> t                             val symmetric_diff :                               t ->                               t ->                               (edge, edge) Core_kernel.Either.t                               Core_kernel.Sequence.t                             val compare_direct : t -> t -> int                             val equal : t -> t -> bool                             val subset : t -> t -> bool                             val fold_until :                               t ->                               init:'->                               f:('->                                  edge -> [ `Continue of '| `Stop of 'b ]) ->                               'b                             val fold_right :                               t -> init:'-> f:(edge -> '-> 'b) -> 'b                             val iter2 :                               t ->                               t ->                               f:([ `Both of edge * edge                                  | `Left of edge                                  | `Right of edge ] -> unit) ->                               unit                             val filter : t -> f:(edge -> bool) -> t                             val partition_tf : t -> f:(edge -> bool) -> t * t                             val elements : t -> edge list                             val min_elt : t -> edge option                             val min_elt_exn : t -> edge                             val max_elt : t -> edge option                             val max_elt_exn : t -> edge                             val choose : t -> edge option                             val choose_exn : t -> edge                             val split : t -> edge -> t * edge option * t                             val group_by :                               t -> equiv:(edge -> edge -> bool) -> t list                             val find_exn : t -> f:(edge -> bool) -> edge                             val find_index : t -> int -> edge option                             val remove_index : t -> int -> t                             val to_tree : t -> t                             val to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t -> edge Core_kernel.Sequence.t                             val merge_to_sequence :                               ?order:[ `Decreasing | `Increasing ] ->                               ?greater_or_equal_to:edge ->                               ?less_or_equal_to:edge ->                               t ->                               t ->                               edge                               Core_kernel.Core_set_intf.Merge_to_sequence_element.t                               Core_kernel.Sequence.t                             val to_map :                               t ->                               f:(edge -> 'data) ->                               (edge, 'data, comparator_witness)                               Core_kernel.Core_set_intf.Map.t                             val obs :                               edge Core_kernel.Quickcheck.obs ->                               t Core_kernel.Quickcheck.obs                             val shrinker :                               edge Core_kernel.Quickcheck.shr ->                               t Core_kernel.Quickcheck.shr                             val empty : t                             val singleton : edge -> t                             val union_list : t list -> t                             val of_list : edge list -> t                             val of_array : edge array -> t                             val of_sorted_array :                               edge array -> t Core_kernel.Or_error.t                             val of_sorted_array_unchecked : edge array -> t                             val stable_dedup_list : edge list -> edge list                             val map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge) -> t                             val filter_map :                               ('a, 'b) Core_kernel.Core_set.Tree.t ->                               f:('-> edge option) -> t                             val of_tree : t -> t                             val of_map_keys :                               (edge, 'a, comparator_witness)                               Core_kernel.Core_set_intf.Map.t -> t                             val gen :                               edge Core_kernel.Quickcheck.Generator.t ->                               t Core_kernel.Quickcheck.Generator.t                           end                         type t =                             (edge, comparator_witness) Core_kernel.Core_set.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(edge -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> edge -> 'accum) -> 'accum                         val exists : t -> f:(edge -> bool) -> bool                         val for_all : t -> f:(edge -> bool) -> bool                         val count : t -> f:(edge -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(edge -> 'sum) -> 'sum                         val find : t -> f:(edge -> bool) -> edge option                         val find_map :                           t -> f:(edge -> 'a option) -> 'a option                         val to_list : t -> edge list                         val to_array : t -> edge array                         val invariants : t -> bool                         val mem : t -> edge -> bool                         val add : t -> edge -> t                         val remove : t -> edge -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (edge, edge) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> edge -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(edge -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of edge * edge                              | `Left of edge                              | `Right of edge ] -> unit) ->                           unit                         val filter : t -> f:(edge -> bool) -> t                         val partition_tf : t -> f:(edge -> bool) -> t * t                         val elements : t -> edge list                         val min_elt : t -> edge option                         val min_elt_exn : t -> edge                         val max_elt : t -> edge option                         val max_elt_exn : t -> edge                         val choose : t -> edge option                         val choose_exn : t -> edge                         val split : t -> edge -> t * edge option * t                         val group_by :                           t -> equiv:(edge -> edge -> bool) -> t list                         val find_exn : t -> f:(edge -> bool) -> edge                         val find_index : t -> int -> edge option                         val remove_index : t -> int -> t                         val to_tree : t -> Tree.t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t -> edge Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:edge ->                           ?less_or_equal_to:edge ->                           t ->                           t ->                           edge                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(edge -> 'data) ->                           (edge, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           edge Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           edge Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : edge -> t                         val union_list : t list -> t                         val of_list : edge list -> t                         val of_array : edge array -> t                         val of_sorted_array :                           edge array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : edge array -> t                         val stable_dedup_list : edge list -> edge list                         val map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.t ->                           f:('-> edge option) -> t                         val of_tree : Tree.t -> t                         val of_map_keys :                           (edge, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           edge Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     val hash : t -> int                     val compare : t -> t -> int                     val hashable :                       t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                     module Table :                       sig                         type key = t                         type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl                         type 'b t = (key, 'b) hashtbl                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                         type ('a, 'b) t_ = 'b t                         type 'a key_ = key                         val hashable :                           key Core_kernel.Core_hashtbl_intf.Hashable.t                         val invariant :                           'Core_kernel.Invariant_intf.inv ->                           'a t Core_kernel.Invariant_intf.inv                         val create :                           (key, 'b, unit -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_key of key | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_report_all_dups :                           (key, 'b,                            (key * 'b) list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_or_error :                           (key, 'b,                            (key * 'b) list -> 'b t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_exn :                           (key, 'b, (key * 'b) list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val of_alist_multi :                           (key, 'b list, (key * 'b) list -> 'b list t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_mapped :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'b t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key :                           (key, 'r,                            get_key:('-> key) ->                            'r list ->                            [ `Duplicate_keys of key list | `Ok of 'r t ])                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_or_error :                           (key, 'r,                            get_key:('-> key) ->                            'r list -> 'r t Core_kernel.Or_error.t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val create_with_key_exn :                           (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val group :                           (key, 'b,                            get_key:('-> key) ->                            get_data:('-> 'b) ->                            combine:('-> '-> 'b) -> 'r list -> 'b t)                           Core_kernel.Core_hashtbl_intf.create_options_without_hashable                         val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                         val clear : 'a t -> unit                         val copy : 'b t -> 'b t                         val fold :                           'b t ->                           init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                         val iter_vals : 'b t -> f:('-> unit) -> unit                         val iteri :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(key -> unit) -> unit                         val iter :                           'b t -> f:(key:key -> data:'-> unit) -> unit                         val existsi :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val exists : 'b t -> f:('-> bool) -> bool                         val for_alli :                           'b t -> f:(key:key -> data:'-> bool) -> bool                         val for_all : 'b t -> f:('-> bool) -> bool                         val counti :                           'b t -> f:(key:key -> data:'-> bool) -> int                         val count : 'b t -> f:('-> bool) -> int                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val mem : 'a t -> key -> bool                         val remove : 'a t -> key -> unit                         val replace : 'b t -> key:key -> data:'-> unit                         val set : 'b t -> key:key -> data:'-> unit                         val add :                           'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                         val add_or_error :                           'b t ->                           key:key -> data:'-> unit Core_kernel.Or_error.t                         val add_exn : 'b t -> key:key -> data:'-> unit                         val change :                           'b t -> key -> f:('b option -> 'b option) -> unit                         val update :                           'b t -> key -> f:('b option -> 'b) -> unit                         val add_multi :                           'b list t -> key:key -> data:'-> unit                         val remove_multi : 'a list t -> key -> unit                         val map :                           ('c, 'b t -> f:('-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val mapi :                           ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_map :                           ('c, 'b t -> f:('-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter_mapi :                           ('c,                            'b t ->                            f:(key:key -> data:'-> 'c option) -> 'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val filter : 'b t -> f:('-> bool) -> 'b t                         val filteri :                           'b t -> f:(key:key -> data:'-> bool) -> 'b t                         val partition_map :                           ('c,                            ('d,                             'b t ->                             f:('-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_mapi :                           ('c,                            ('d,                             'b t ->                             f:(key:key ->                                data:'-> [ `Fst of '| `Snd of 'd ]) ->                             'c t * 'd t)                            Core_kernel.Core_hashtbl_intf.no_map_options)                           Core_kernel.Core_hashtbl_intf.no_map_options                         val partition_tf :                           'b t -> f:('-> bool) -> 'b t * 'b t                         val partitioni_tf :                           'b t ->                           f:(key:key -> data:'-> bool) -> 'b t * 'b t                         val find_or_add :                           'b t -> key -> default:(unit -> 'b) -> 'b                         val find : 'b t -> key -> 'b option                         val find_exn : 'b t -> key -> 'b                         val find_and_call :                           'b t ->                           key ->                           if_found:('-> 'c) ->                           if_not_found:(key -> 'c) -> 'c                         val find_and_remove : 'b t -> key -> 'b option                         val merge :                           ('c,                            'a t ->                            'b t ->                            f:(key:key ->                               [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                               'c option) ->                            'c t)                           Core_kernel.Core_hashtbl_intf.no_map_options                         type 'a merge_into_action = Remove | Set_to of 'a                         val merge_into :                           src:'a t ->                           dst:'b t ->                           f:(key:key ->                              '-> 'b option -> 'b merge_into_action) ->                           unit                         val keys : 'a t -> key list                         val data : 'b t -> 'b list                         val filter_inplace : 'b t -> f:('-> bool) -> unit                         val filteri_inplace :                           'b t -> f:(key:key -> data:'-> bool) -> unit                         val filter_keys_inplace :                           'a t -> f:(key -> bool) -> unit                         val map_inplace : 'b t -> f:('-> 'b) -> unit                         val mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_map_inplace :                           'b t -> f:('-> 'b option) -> unit                         val filter_mapi_inplace :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val replace_all : 'b t -> f:('-> 'b) -> unit                         val replace_alli :                           'b t -> f:(key:key -> data:'-> 'b) -> unit                         val filter_replace_all :                           'b t -> f:('-> 'b option) -> unit                         val filter_replace_alli :                           'b t -> f:(key:key -> data:'-> 'b option) -> unit                         val equal :                           'b t -> 'b t -> ('-> '-> bool) -> bool                         val similar :                           'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                         val to_alist : 'b t -> (key * 'b) list                         val validate :                           name:(key -> string) ->                           'Core_kernel.Validate.check ->                           'b t Core_kernel.Validate.check                         val incr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                         val decr :                           ?by:int ->                           ?remove_if_zero:bool -> int t -> key -> unit                       end                     module Hash_set :                       sig                         type elt = t                         type 'a hash_set = 'Node.Hash_set.hash_set                         type t = elt hash_set                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type 'a t_ = t                         type 'a elt_ = elt                         val create :                           ('a, unit -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                         val of_list :                           ('a, elt list -> t)                           Core_kernel.Hash_set_intf.create_options_without_hashable                       end                     module Hash_queue :                       sig                         module Key :                           sig                             type t = edge                             val t_of_sexp : Sexplib.Sexp.t -> t                             val sexp_of_t : t -> Sexplib.Sexp.t                             val compare : t -> t -> int                             val hash : t -> int                           end                         type 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val length : 'a t -> int                         val is_empty : 'a t -> bool                         val iter : 'a t -> f:('-> unit) -> unit                         val fold :                           'a t ->                           init:'accum -> f:('accum -> '-> 'accum) -> 'accum                         val exists : 'a t -> f:('-> bool) -> bool                         val for_all : 'a t -> f:('-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           'a t -> f:('-> 'sum) -> 'sum                         val find : 'a t -> f:('-> bool) -> 'a option                         val find_map :                           'a t -> f:('-> 'b option) -> 'b option                         val to_list : 'a t -> 'a list                         val to_array : 'a t -> 'a array                         val min_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val max_elt :                           'a t -> cmp:('-> '-> int) -> 'a option                         val invariant : 'a t -> unit                         val create :                           ?growth_allowed:bool -> ?size:int -> unit -> 'a t                         val clear : 'a t -> unit                         val mem : 'a t -> edge -> bool                         val lookup : 'a t -> edge -> 'a option                         val lookup_exn : 'a t -> edge -> 'a                         val enqueue :                           'a t ->                           edge -> '-> [ `Key_already_present | `Ok ]                         val enqueue_exn : 'a t -> edge -> '-> unit                         val first : 'a t -> 'a option                         val first_with_key : 'a t -> (edge * 'a) option                         val keys : 'a t -> edge list                         val dequeue : 'a t -> 'a option                         val dequeue_exn : 'a t -> 'a                         val dequeue_with_key : 'a t -> (edge * 'a) option                         val dequeue_with_key_exn : 'a t -> edge * 'a                         val dequeue_all : 'a t -> f:('-> unit) -> unit                         val remove : 'a t -> edge -> [ `No_such_key | `Ok ]                         val remove_exn : 'a t -> edge -> unit                         val replace :                           'a t -> edge -> '-> [ `No_such_key | `Ok ]                         val replace_exn : 'a t -> edge -> '-> unit                         val iteri :                           'a t -> f:(key:edge -> data:'-> unit) -> unit                         val foldi :                           'a t ->                           init:'->                           f:('-> key:edge -> data:'-> 'b) -> 'b                       end                   end                 val empty : t                 val nodes : t -> node Regular.Std.seq                 val edges : t -> edge Regular.Std.seq                 val is_directed : bool                 val number_of_edges : t -> int                 val number_of_nodes : t -> int                 val ( >= ) : t -> t -> bool                 val ( <= ) : t -> t -> bool                 val ( = ) : t -> t -> bool                 val ( > ) : t -> t -> bool                 val ( < ) : t -> t -> bool                 val ( <> ) : t -> t -> bool                 val equal : t -> t -> bool                 val min : t -> t -> t                 val max : t -> t -> t                 val ascending : t -> t -> int                 val descending : t -> t -> int                 val between : t -> low:t -> high:t -> bool                 val clamp_exn : t -> min:t -> max:t -> t                 val clamp : t -> min:t -> max:t -> t Core_kernel.Or_error.t                 module Replace_polymorphic_compare :                   sig                     val ( >= ) : t -> t -> bool                     val ( <= ) : t -> t -> bool                     val ( = ) : t -> t -> bool                     val ( > ) : t -> t -> bool                     val ( < ) : t -> t -> bool                     val ( <> ) : t -> t -> bool                     val equal : t -> t -> bool                     val compare : t -> t -> int                     val min : t -> t -> t                     val max : t -> t -> t                   end                 type comparator_witness                 val comparator :                   (t, comparator_witness) Core_kernel.Comparator.comparator                 val validate_lbound :                   min:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_ubound :                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 val validate_bound :                   min:t Core_kernel.Maybe_bound.t ->                   max:t Core_kernel.Maybe_bound.t ->                   t Core_kernel.Validate.check                 module Map :                   sig                     module Key :                       sig                         type t = Edge.graph                         type comparator_witness = comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type 'a t =                             (Key.t, 'a, comparator_witness)                             Core_kernel.Core_map.Tree.t                         val t_of_sexp :                           (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                         val sexp_of_t :                           ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                         val empty : 'a t                         val singleton : Key.t -> '-> 'a t                         val of_alist :                           (Key.t * 'a) list ->                           [ `Duplicate_key of Key.t | `Ok of 'a t ]                         val of_alist_or_error :                           (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                         val of_alist_exn : (Key.t * 'a) list -> 'a t                         val of_alist_multi : (Key.t * 'a) list -> 'a list t                         val of_alist_fold :                           (Key.t * 'a) list ->                           init:'-> f:('-> '-> 'b) -> 'b t                         val of_alist_reduce :                           (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                         val of_sorted_array :                           (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                         val of_sorted_array_unchecked :                           (Key.t * 'a) array -> 'a t                         val of_tree : 'a t -> 'a t                         val gen :                           Key.t Core_kernel.Quickcheck.Generator.t ->                           'Core_kernel.Quickcheck.Generator.t ->                           'a t Core_kernel.Quickcheck.Generator.t                         val invariants : 'a t -> bool                         val is_empty : 'a t -> bool                         val length : 'a t -> int                         val add : 'a t -> key:Key.t -> data:'-> 'a t                         val add_multi :                           'a list t -> key:Key.t -> data:'-> 'a list t                         val remove_multi : 'a list t -> Key.t -> 'a list t                         val change :                           'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                         val update :                           'a t -> Key.t -> f:('a option -> 'a) -> 'a t                         val find : 'a t -> Key.t -> 'a option                         val find_exn : 'a t -> Key.t -> 'a                         val remove : 'a t -> Key.t -> 'a t                         val mem : 'a t -> Key.t -> bool                         val iter :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iteri :                           'a t -> f:(key:Key.t -> data:'-> unit) -> unit                         val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                         val iter2 :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              unit) ->                           unit                         val map : 'a t -> f:('-> 'b) -> 'b t                         val mapi :                           'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                         val fold :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold_right :                           'a t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val fold2 :                           'a t ->                           'b t ->                           init:'->                           f:(key:Key.t ->                              data:[ `Both of 'a * 'b                                   | `Left of 'a                                   | `Right of 'b ] ->                              '-> 'c) ->                           'c                         val filter :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filteri :                           'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                         val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                         val filter_map : 'a t -> f:('-> 'b option) -> 'b t                         val filter_mapi :                           'a t ->                           f:(key:Key.t -> data:'-> 'b option) -> 'b t                         val partition_mapi :                           'a t ->                           f:(key:Key.t ->                              data:'-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partition_map :                           'a t ->                           f:('-> [ `Fst of '| `Snd of 'c ]) ->                           'b t * 'c t                         val partitioni_tf :                           'a t ->                           f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                         val partition_tf :                           'a t -> f:('-> bool) -> 'a t * 'a t                         val compare_direct :                           ('-> '-> int) -> 'a t -> 'a t -> int                         val equal :                           ('-> '-> bool) -> 'a t -> 'a t -> bool                         val keys : 'a t -> Key.t list                         val data : 'a t -> 'a list                         val to_alist :                           ?key_order:[ `Decreasing | `Increasing ] ->                           'a t -> (Key.t * 'a) list                         val validate :                           name:(Key.t -> string) ->                           'Core_kernel.Validate.check ->                           'a t Core_kernel.Validate.check                         val merge :                           'a t ->                           'b t ->                           f:(key:Key.t ->                              [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                              'c option) ->                           'c t                         val symmetric_diff :                           'a t ->                           'a t ->                           data_equal:('-> '-> bool) ->                           (Key.t, 'a)                           Core_kernel.Core_map_intf.Symmetric_diff_element.t                           Core_kernel.Sequence.t                         val min_elt : 'a t -> (Key.t * 'a) option                         val min_elt_exn : 'a t -> Key.t * 'a                         val max_elt : 'a t -> (Key.t * 'a) option                         val max_elt_exn : 'a t -> Key.t * 'a                         val for_all : 'a t -> f:('-> bool) -> bool                         val for_alli :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val exists : 'a t -> f:('-> bool) -> bool                         val existsi :                           'a t -> f:(key:Key.t -> data:'-> bool) -> bool                         val count : 'a t -> f:('-> bool) -> int                         val counti :                           'a t -> f:(key:Key.t -> data:'-> bool) -> int                         val split :                           'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                         val fold_range_inclusive :                           'a t ->                           min:Key.t ->                           max:Key.t ->                           init:'->                           f:(key:Key.t -> data:'-> '-> 'b) -> 'b                         val range_to_alist :                           'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                         val closest_key :                           'a t ->                           [ `Greater_or_equal_to                           | `Greater_than                           | `Less_or_equal_to                           | `Less_than ] -> Key.t -> (Key.t * 'a) option                         val nth : 'a t -> int -> (Key.t * 'a) option                         val rank : 'a t -> Key.t -> int option                         val to_tree : 'a t -> 'a t                         val to_sequence :                           ?order:[ `Decreasing_key | `Increasing_key ] ->                           ?keys_greater_or_equal_to:Key.t ->                           ?keys_less_or_equal_to:Key.t ->                           'a t -> (Key.t * 'a) Core_kernel.Sequence.t                         val obs :                           Key.t Core_kernel.Quickcheck.Observer.t ->                           'Core_kernel.Quickcheck.Observer.t ->                           'v t Core_kernel.Quickcheck.Observer.t                         val shrinker :                           Key.t Core_kernel.Quickcheck.Shrinker.t ->                           'Core_kernel.Quickcheck.Shrinker.t ->                           'v t Core_kernel.Quickcheck.Shrinker.t                       end                     type 'a t =                         (Key.t, 'a, comparator_witness)                         Core_kernel.Core_map.t                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val compare : ('-> '-> int) -> 'a t -> 'a t -> int                     val empty : 'a t                     val singleton : Key.t -> '-> 'a t                     val of_alist :                       (Key.t * 'a) list ->                       [ `Duplicate_key of Key.t | `Ok of 'a t ]                     val of_alist_or_error :                       (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t                     val of_alist_exn : (Key.t * 'a) list -> 'a t                     val of_alist_multi : (Key.t * 'a) list -> 'a list t                     val of_alist_fold :                       (Key.t * 'a) list ->                       init:'-> f:('-> '-> 'b) -> 'b t                     val of_alist_reduce :                       (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t                     val of_sorted_array :                       (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t                     val of_sorted_array_unchecked :                       (Key.t * 'a) array -> 'a t                     val of_tree : 'Tree.t -> 'a t                     val gen :                       Key.t Core_kernel.Quickcheck.Generator.t ->                       'Core_kernel.Quickcheck.Generator.t ->                       'a t Core_kernel.Quickcheck.Generator.t                     val invariants : 'a t -> bool                     val is_empty : 'a t -> bool                     val length : 'a t -> int                     val add : 'a t -> key:Key.t -> data:'-> 'a t                     val add_multi :                       'a list t -> key:Key.t -> data:'-> 'a list t                     val remove_multi : 'a list t -> Key.t -> 'a list t                     val change :                       'a t -> Key.t -> f:('a option -> 'a option) -> 'a t                     val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t                     val find : 'a t -> Key.t -> 'a option                     val find_exn : 'a t -> Key.t -> 'a                     val remove : 'a t -> Key.t -> 'a t                     val mem : 'a t -> Key.t -> bool                     val iter :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(Key.t -> unit) -> unit                     val iter2 :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          unit) ->                       unit                     val map : 'a t -> f:('-> 'b) -> 'b t                     val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t                     val fold :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold_right :                       'a t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val fold2 :                       'a t ->                       'b t ->                       init:'->                       f:(key:Key.t ->                          data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          '-> 'c) ->                       'c                     val filter :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filteri :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t                     val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t                     val filter_map : 'a t -> f:('-> 'b option) -> 'b t                     val filter_mapi :                       'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t                     val partition_mapi :                       'a t ->                       f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->                       'b t * 'c t                     val partition_map :                       'a t ->                       f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t                     val partitioni_tf :                       'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t                     val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t                     val compare_direct :                       ('-> '-> int) -> 'a t -> 'a t -> int                     val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool                     val keys : 'a t -> Key.t list                     val data : 'a t -> 'a list                     val to_alist :                       ?key_order:[ `Decreasing | `Increasing ] ->                       'a t -> (Key.t * 'a) list                     val validate :                       name:(Key.t -> string) ->                       'Core_kernel.Validate.check ->                       'a t Core_kernel.Validate.check                     val merge :                       'a t ->                       'b t ->                       f:(key:Key.t ->                          [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                          'c option) ->                       'c t                     val symmetric_diff :                       'a t ->                       'a t ->                       data_equal:('-> '-> bool) ->                       (Key.t, 'a)                       Core_kernel.Core_map_intf.Symmetric_diff_element.t                       Core_kernel.Sequence.t                     val min_elt : 'a t -> (Key.t * 'a) option                     val min_elt_exn : 'a t -> Key.t * 'a                     val max_elt : 'a t -> (Key.t * 'a) option                     val max_elt_exn : 'a t -> Key.t * 'a                     val for_all : 'a t -> f:('-> bool) -> bool                     val for_alli :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val exists : 'a t -> f:('-> bool) -> bool                     val existsi :                       'a t -> f:(key:Key.t -> data:'-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val counti :                       'a t -> f:(key:Key.t -> data:'-> bool) -> int                     val split :                       'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t                     val fold_range_inclusive :                       'a t ->                       min:Key.t ->                       max:Key.t ->                       init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b                     val range_to_alist :                       'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list                     val closest_key :                       'a t ->                       [ `Greater_or_equal_to                       | `Greater_than                       | `Less_or_equal_to                       | `Less_than ] -> Key.t -> (Key.t * 'a) option                     val nth : 'a t -> int -> (Key.t * 'a) option                     val rank : 'a t -> Key.t -> int option                     val to_tree : 'a t -> 'Tree.t                     val to_sequence :                       ?order:[ `Decreasing_key | `Increasing_key ] ->                       ?keys_greater_or_equal_to:Key.t ->                       ?keys_less_or_equal_to:Key.t ->                       'a t -> (Key.t * 'a) Core_kernel.Sequence.t                     val obs :                       Key.t Core_kernel.Quickcheck.Observer.t ->                       'Core_kernel.Quickcheck.Observer.t ->                       'v t Core_kernel.Quickcheck.Observer.t                     val shrinker :                       Key.t Core_kernel.Quickcheck.Shrinker.t ->                       'Core_kernel.Quickcheck.Shrinker.t ->                       'v t Core_kernel.Quickcheck.Shrinker.t                   end                 module Set :                   sig                     module Elt :                       sig                         type t = Edge.graph                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         type comparator_witness = Map.Key.comparator_witness                         val comparator :                           (t, comparator_witness)                           Core_kernel.Comparator.comparator                       end                     module Tree :                       sig                         type t =                             (Elt.t, comparator_witness)                             Core_kernel.Core_set.Tree.t                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val length : t -> int                         val is_empty : t -> bool                         val iter : t -> f:(Elt.t -> unit) -> unit                         val fold :                           t ->                           init:'accum ->                           f:('accum -> Elt.t -> 'accum) -> 'accum                         val exists : t -> f:(Elt.t -> bool) -> bool                         val for_all : t -> f:(Elt.t -> bool) -> bool                         val count : t -> f:(Elt.t -> bool) -> int                         val sum :                           (module Core_kernel.Commutative_group.S with type t = 'sum) ->                           t -> f:(Elt.t -> 'sum) -> 'sum                         val find : t -> f:(Elt.t -> bool) -> Elt.t option                         val find_map :                           t -> f:(Elt.t -> 'a option) -> 'a option                         val to_list : t -> Elt.t list                         val to_array : t -> Elt.t array                         val invariants : t -> bool                         val mem : t -> Elt.t -> bool                         val add : t -> Elt.t -> t                         val remove : t -> Elt.t -> t                         val union : t -> t -> t                         val inter : t -> t -> t                         val diff : t -> t -> t                         val symmetric_diff :                           t ->                           t ->                           (Elt.t, Elt.t) Core_kernel.Either.t                           Core_kernel.Sequence.t                         val compare_direct : t -> t -> int                         val equal : t -> t -> bool                         val subset : t -> t -> bool                         val fold_until :                           t ->                           init:'->                           f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                           'b                         val fold_right :                           t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                         val iter2 :                           t ->                           t ->                           f:([ `Both of Elt.t * Elt.t                              | `Left of Elt.t                              | `Right of Elt.t ] -> unit) ->                           unit                         val filter : t -> f:(Elt.t -> bool) -> t                         val partition_tf : t -> f:(Elt.t -> bool) -> t * t                         val elements : t -> Elt.t list                         val min_elt : t -> Elt.t option                         val min_elt_exn : t -> Elt.t                         val max_elt : t -> Elt.t option                         val max_elt_exn : t -> Elt.t                         val choose : t -> Elt.t option                         val choose_exn : t -> Elt.t                         val split : t -> Elt.t -> t * Elt.t option * t                         val group_by :                           t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                         val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                         val find_index : t -> int -> Elt.t option                         val remove_index : t -> int -> t                         val to_tree : t -> t                         val to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t -> Elt.t Core_kernel.Sequence.t                         val merge_to_sequence :                           ?order:[ `Decreasing | `Increasing ] ->                           ?greater_or_equal_to:Elt.t ->                           ?less_or_equal_to:Elt.t ->                           t ->                           t ->                           Elt.t                           Core_kernel.Core_set_intf.Merge_to_sequence_element.t                           Core_kernel.Sequence.t                         val to_map :                           t ->                           f:(Elt.t -> 'data) ->                           (Elt.t, 'data, comparator_witness)                           Core_kernel.Core_set_intf.Map.t                         val obs :                           Elt.t Core_kernel.Quickcheck.obs ->                           t Core_kernel.Quickcheck.obs                         val shrinker :                           Elt.t Core_kernel.Quickcheck.shr ->                           t Core_kernel.Quickcheck.shr                         val empty : t                         val singleton : Elt.t -> t                         val union_list : t list -> t                         val of_list : Elt.t list -> t                         val of_array : Elt.t array -> t                         val of_sorted_array :                           Elt.t array -> t Core_kernel.Or_error.t                         val of_sorted_array_unchecked : Elt.t array -> t                         val stable_dedup_list : Elt.t list -> Elt.t list                         val map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t) -> t                         val filter_map :                           ('a, 'b) Core_kernel.Core_set.Tree.t ->                           f:('-> Elt.t option) -> t                         val of_tree : t -> t                         val of_map_keys :                           (Elt.t, 'a, comparator_witness)                           Core_kernel.Core_set_intf.Map.t -> t                         val gen :                           Elt.t Core_kernel.Quickcheck.Generator.t ->                           t Core_kernel.Quickcheck.Generator.t                       end                     type t =                         (Elt.t, comparator_witness) Core_kernel.Core_set.t                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     val compare : t -> t -> int                     val length : t -> int                     val is_empty : t -> bool                     val iter : t -> f:(Elt.t -> unit) -> unit                     val fold :                       t ->                       init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum                     val exists : t -> f:(Elt.t -> bool) -> bool                     val for_all : t -> f:(Elt.t -> bool) -> bool                     val count : t -> f:(Elt.t -> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       t -> f:(Elt.t -> 'sum) -> 'sum                     val find : t -> f:(Elt.t -> bool) -> Elt.t option                     val find_map : t -> f:(Elt.t -> 'a option) -> 'a option                     val to_list : t -> Elt.t list                     val to_array : t -> Elt.t array                     val invariants : t -> bool                     val mem : t -> Elt.t -> bool                     val add : t -> Elt.t -> t                     val remove : t -> Elt.t -> t                     val union : t -> t -> t                     val inter : t -> t -> t                     val diff : t -> t -> t                     val symmetric_diff :                       t ->                       t ->                       (Elt.t, Elt.t) Core_kernel.Either.t                       Core_kernel.Sequence.t                     val compare_direct : t -> t -> int                     val equal : t -> t -> bool                     val subset : t -> t -> bool                     val fold_until :                       t ->                       init:'->                       f:('-> Elt.t -> [ `Continue of '| `Stop of 'b ]) ->                       'b                     val fold_right :                       t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b                     val iter2 :                       t ->                       t ->                       f:([ `Both of Elt.t * Elt.t                          | `Left of Elt.t                          | `Right of Elt.t ] -> unit) ->                       unit                     val filter : t -> f:(Elt.t -> bool) -> t                     val partition_tf : t -> f:(Elt.t -> bool) -> t * t                     val elements : t -> Elt.t list                     val min_elt : t -> Elt.t option                     val min_elt_exn : t -> Elt.t                     val max_elt : t -> Elt.t option                     val max_elt_exn : t -> Elt.t                     val choose : t -> Elt.t option                     val choose_exn : t -> Elt.t                     val split : t -> Elt.t -> t * Elt.t option * t                     val group_by :                       t -> equiv:(Elt.t -> Elt.t -> bool) -> t list                     val find_exn : t -> f:(Elt.t -> bool) -> Elt.t                     val find_index : t -> int -> Elt.t option                     val remove_index : t -> int -> t                     val to_tree : t -> Tree.t                     val to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t -> Elt.t Core_kernel.Sequence.t                     val merge_to_sequence :                       ?order:[ `Decreasing | `Increasing ] ->                       ?greater_or_equal_to:Elt.t ->                       ?less_or_equal_to:Elt.t ->                       t ->                       t ->                       Elt.t                       Core_kernel.Core_set_intf.Merge_to_sequence_element.t                       Core_kernel.Sequence.t                     val to_map :                       t ->                       f:(Elt.t -> 'data) ->                       (Elt.t, 'data, comparator_witness)                       Core_kernel.Core_set_intf.Map.t                     val obs :                       Elt.t Core_kernel.Quickcheck.obs ->                       t Core_kernel.Quickcheck.obs                     val shrinker :                       Elt.t Core_kernel.Quickcheck.shr ->                       t Core_kernel.Quickcheck.shr                     val empty : t                     val singleton : Elt.t -> t                     val union_list : t list -> t                     val of_list : Elt.t list -> t                     val of_array : Elt.t array -> t                     val of_sorted_array :                       Elt.t array -> t Core_kernel.Or_error.t                     val of_sorted_array_unchecked : Elt.t array -> t                     val stable_dedup_list : Elt.t list -> Elt.t list                     val map :                       ('a, 'b) Core_kernel.Core_set.t -> f:('-> Elt.t) -> t                     val filter_map :                       ('a, 'b) Core_kernel.Core_set.t ->                       f:('-> Elt.t option) -> t                     val of_tree : Tree.t -> t                     val of_map_keys :                       (Elt.t, 'a, comparator_witness)                       Core_kernel.Core_set_intf.Map.t -> t                     val gen :                       Elt.t Core_kernel.Quickcheck.Generator.t ->                       t Core_kernel.Quickcheck.Generator.t                   end                 val hash : t -> int                 val compare : t -> t -> int                 val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t                 module Table :                   sig                     type key = t                     type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl                     type 'b t = (key, 'b) hashtbl                     val t_of_sexp :                       (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t                     type ('a, 'b) t_ = 'b t                     type 'a key_ = key                     val hashable :                       key Core_kernel.Core_hashtbl_intf.Hashable.t                     val invariant :                       'Core_kernel.Invariant_intf.inv ->                       'a t Core_kernel.Invariant_intf.inv                     val create :                       (key, 'b, unit -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_key of key | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_report_all_dups :                       (key, 'b,                        (key * 'b) list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_or_error :                       (key, 'b,                        (key * 'b) list -> 'b t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_exn :                       (key, 'b, (key * 'b) list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val of_alist_multi :                       (key, 'b list, (key * 'b) list -> 'b list t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_mapped :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'b t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key :                       (key, 'r,                        get_key:('-> key) ->                        'r list ->                        [ `Duplicate_keys of key list | `Ok of 'r t ])                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_or_error :                       (key, 'r,                        get_key:('-> key) ->                        'r list -> 'r t Core_kernel.Or_error.t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val create_with_key_exn :                       (key, 'r, get_key:('-> key) -> 'r list -> 'r t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val group :                       (key, 'b,                        get_key:('-> key) ->                        get_data:('-> 'b) ->                        combine:('-> '-> 'b) -> 'r list -> 'b t)                       Core_kernel.Core_hashtbl_intf.create_options_without_hashable                     val sexp_of_key : 'a t -> key -> Sexplib.Sexp.t                     val clear : 'a t -> unit                     val copy : 'b t -> 'b t                     val fold :                       'b t ->                       init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c                     val iter_vals : 'b t -> f:('-> unit) -> unit                     val iteri :                       'b t -> f:(key:key -> data:'-> unit) -> unit                     val iter_keys : 'a t -> f:(key -> unit) -> unit                     val iter : 'b t -> f:(key:key -> data:'-> unit) -> unit                     val existsi :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val exists : 'b t -> f:('-> bool) -> bool                     val for_alli :                       'b t -> f:(key:key -> data:'-> bool) -> bool                     val for_all : 'b t -> f:('-> bool) -> bool                     val counti :                       'b t -> f:(key:key -> data:'-> bool) -> int                     val count : 'b t -> f:('-> bool) -> int                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val mem : 'a t -> key -> bool                     val remove : 'a t -> key -> unit                     val replace : 'b t -> key:key -> data:'-> unit                     val set : 'b t -> key:key -> data:'-> unit                     val add :                       'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]                     val add_or_error :                       'b t ->                       key:key -> data:'-> unit Core_kernel.Or_error.t                     val add_exn : 'b t -> key:key -> data:'-> unit                     val change :                       'b t -> key -> f:('b option -> 'b option) -> unit                     val update : 'b t -> key -> f:('b option -> 'b) -> unit                     val add_multi : 'b list t -> key:key -> data:'-> unit                     val remove_multi : 'a list t -> key -> unit                     val map :                       ('c, 'b t -> f:('-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val mapi :                       ('c, 'b t -> f:(key:key -> data:'-> 'c) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_map :                       ('c, 'b t -> f:('-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter_mapi :                       ('c,                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val filter : 'b t -> f:('-> bool) -> 'b t                     val filteri :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t                     val partition_map :                       ('c,                        ('d,                         'b t ->                         f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_mapi :                       ('c,                        ('d,                         'b t ->                         f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->                         'c t * 'd t)                        Core_kernel.Core_hashtbl_intf.no_map_options)                       Core_kernel.Core_hashtbl_intf.no_map_options                     val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t                     val partitioni_tf :                       'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t                     val find_or_add :                       'b t -> key -> default:(unit -> 'b) -> 'b                     val find : 'b t -> key -> 'b option                     val find_exn : 'b t -> key -> 'b                     val find_and_call :                       'b t ->                       key ->                       if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c                     val find_and_remove : 'b t -> key -> 'b option                     val merge :                       ('c,                        'a t ->                        'b t ->                        f:(key:key ->                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->                           'c option) ->                        'c t)                       Core_kernel.Core_hashtbl_intf.no_map_options                     type 'a merge_into_action = Remove | Set_to of 'a                     val merge_into :                       src:'a t ->                       dst:'b t ->                       f:(key:key -> '-> 'b option -> 'b merge_into_action) ->                       unit                     val keys : 'a t -> key list                     val data : 'b t -> 'b list                     val filter_inplace : 'b t -> f:('-> bool) -> unit                     val filteri_inplace :                       'b t -> f:(key:key -> data:'-> bool) -> unit                     val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit                     val map_inplace : 'b t -> f:('-> 'b) -> unit                     val mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_map_inplace :                       'b t -> f:('-> 'b option) -> unit                     val filter_mapi_inplace :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val replace_all : 'b t -> f:('-> 'b) -> unit                     val replace_alli :                       'b t -> f:(key:key -> data:'-> 'b) -> unit                     val filter_replace_all :                       'b t -> f:('-> 'b option) -> unit                     val filter_replace_alli :                       'b t -> f:(key:key -> data:'-> 'b option) -> unit                     val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool                     val similar :                       'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool                     val to_alist : 'b t -> (key * 'b) list                     val validate :                       name:(key -> string) ->                       'Core_kernel.Validate.check ->                       'b t Core_kernel.Validate.check                     val incr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                     val decr :                       ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit                   end                 module Hash_set :                   sig                     type elt = t                     type 'a hash_set = 'Edge.Hash_set.hash_set                     type t = elt hash_set                     val t_of_sexp : Sexplib.Sexp.t -> t                     val sexp_of_t : t -> Sexplib.Sexp.t                     type 'a t_ = t                     type 'a elt_ = elt                     val create :                       ('a, unit -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                     val of_list :                       ('a, elt list -> t)                       Core_kernel.Hash_set_intf.create_options_without_hashable                   end                 module Hash_queue :                   sig                     module Key :                       sig                         type t = Hash_set.elt                         val t_of_sexp : Sexplib.Sexp.t -> t                         val sexp_of_t : t -> Sexplib.Sexp.t                         val compare : t -> t -> int                         val hash : t -> int                       end                     type 'a t                     val sexp_of_t :                       ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t                     val length : 'a t -> int                     val is_empty : 'a t -> bool                     val iter : 'a t -> f:('-> unit) -> unit                     val fold :                       'a t ->                       init:'accum -> f:('accum -> '-> 'accum) -> 'accum                     val exists : 'a t -> f:('-> bool) -> bool                     val for_all : 'a t -> f:('-> bool) -> bool                     val count : 'a t -> f:('-> bool) -> int                     val sum :                       (module Core_kernel.Commutative_group.S with type t = 'sum) ->                       'a t -> f:('-> 'sum) -> 'sum                     val find : 'a t -> f:('-> bool) -> 'a option                     val find_map : 'a t -> f:('-> 'b option) -> 'b option                     val to_list : 'a t -> 'a list                     val to_array : 'a t -> 'a array                     val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option                     val invariant : 'a t -> unit                     val create :                       ?growth_allowed:bool -> ?size:int -> unit -> 'a t                     val clear : 'a t -> unit                     val mem : 'a t -> Key.t -> bool                     val lookup : 'a t -> Key.t -> 'a option                     val lookup_exn : 'a t -> Key.t -> 'a                     val enqueue :                       'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]                     val enqueue_exn : 'a t -> Key.t -> '-> unit                     val first : 'a t -> 'a option                     val first_with_key : 'a t -> (Key.t * 'a) option                     val keys : 'a t -> Key.t list                     val dequeue : 'a t -> 'a option                     val dequeue_exn : 'a t -> 'a                     val dequeue_with_key : 'a t -> (Key.t * 'a) option                     val dequeue_with_key_exn : 'a t -> Key.t * 'a                     val dequeue_all : 'a t -> f:('-> unit) -> unit                     val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]                     val remove_exn : 'a t -> Key.t -> unit                     val replace :                       'a t -> Key.t -> '-> [ `No_such_key | `Ok ]                     val replace_exn : 'a t -> Key.t -> '-> unit                     val iteri :                       'a t -> f:(key:Key.t -> data:'-> unit) -> unit                     val foldi :                       'a t ->                       init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b                   end                 val to_string : t -> string                 val str : unit -> t -> string                 val pps : unit -> t -> string                 val ppo : Core_kernel.Std.out_channel -> t -> unit                 val pp_seq :                   Format.formatter -> t Core_kernel.Std.Sequence.t -> unit                 val pp : Format.formatter -> t -> unit               end           type scheme           type 'a symbolizer = '-> string           val create_scheme :             next:(string -> string) -> string -> Graphlib.Std.Graphlib.scheme           val symbols : Graphlib.Std.Graphlib.scheme           val numbers : Graphlib.Std.Graphlib.scheme           val nothing : Graphlib.Std.Graphlib.scheme           val by_given_order :             Graphlib.Std.Graphlib.scheme ->             ('-> '-> int) ->             'Core_kernel.Std.Sequence.t ->             'Graphlib.Std.Graphlib.symbolizer           val by_natural_order :             Graphlib.Std.Graphlib.scheme ->             ('-> '-> int) ->             'Core_kernel.Std.Sequence.t ->             'Graphlib.Std.Graphlib.symbolizer           module Dot :             sig               val pp_graph :                 ?name:string ->                 ?attrs:string list ->                 ?string_of_node:'Graphlib.Std.Graphlib.symbolizer ->                 ?node_label:'Graphlib.Std.Graphlib.symbolizer ->                 ?edge_label:'Graphlib.Std.Graphlib.symbolizer ->                 nodes_of_edge:('-> 'n * 'n) ->                 nodes:'Core_kernel.Std.Sequence.t ->                 edges:'Core_kernel.Std.Sequence.t ->                 Format.formatter -> unit             end         end     end end